static LOCAL_LOCKER: Lazy<HashMap<String, ()>> = Lazy::new(|| HashMap::new());
 
-#[derive(Clone)]
-pub struct LockHolder;
-
-pub async fn lock(key: &str) -> OccupiedEntry<'_, String, ()> {
-    LOCAL_LOCKER
-        .entry_async(key.to_string())
-        .await
-        .or_insert_with(|| ())
+pub struct LocalLockGuard<'a> {
+    entry: OccupiedEntry<'a, String, ()>,
 }
 
+impl<'a> Drop for LocalLockGuard<'a> {
+    fn drop(&mut self) {
+        // Remove the key to allow the next waiter to acquire it.
+        let _ = self.entry.remove_entry();
+    }
+}
+
+pub async fn lock(key: &str) -> LocalLockGuard<'_> {
+    // Spin until we can insert the key and obtain an occupied entry.
+    loop {
+        match LOCAL_LOCKER.entry_async(key.to_string()).await {
+            scc::hash_map::Entry::Occupied(entry) => {
+                // Someone else holds the lock; yield and retry.
+                tokio::task::yield_now().await;
+                continue;
+            }
+            scc::hash_map::Entry::Vacant(v) => {
+                let _ = v.insert(());
+                // Re-acquire as occupied to hold it.
+                if let scc::hash_map::Entry::Occupied(entry) =
+                    LOCAL_LOCKER.entry_async(key.to_string()).await
+                {
+                    return LocalLockGuard { entry };
+                }
+            }
+        }
+    }
+}
+

-pub async fn lock(key: &str) -> OccupiedEntry<'_, String, ()> {
-    LOCAL_LOCKER
-        .entry_async(key.to_string())
-        .await
-        .or_insert_with(|| ())
+pub struct LocalLockGuard<'a> {
+    key: String,
+    _marker: std::marker::PhantomData<&'a ()>,
 }
 
+impl<'a> Drop for LocalLockGuard<'a> {
+    fn drop(&mut self) {
+        let _ = LOCAL_LOCKER.remove(&self.key);
+    }
+}
+
+pub async fn lock(key: &str) -> LocalLockGuard<'_> {
+    let key_owned = key.to_string();
+    // Acquire by inserting when absent; retry until success.
+    loop {
+        if LOCAL_LOCKER
+            .entry_async(key_owned.clone())
+            .await
+            .or_insert_with(|| ())
+            .is_vacant()
+        {
+            continue;
+        } else {
+            // We successfully inserted (or saw existing); ensure we only proceed on first insertion.
+            if LOCAL_LOCKER.read(&key_owned, |_, _| ()).is_some() {
+                return LocalLockGuard {
+                    key: key_owned,
+                    _marker: std::marker::PhantomData,
+                };
+            }
+        }
+        tokio::task::yield_now().await;
+    }
+}
+

 let cache_key = format!("{org_id}/{stream_type}/{stream_name}");
-let _guard = infra::local_lock::lock(&cache_key).await;
+{
+    let _guard = infra::local_lock::lock(&cache_key).await;
+    // guarded operations follow...
+    // check if the schema has been updated by another thread
+    let read_cache = STREAM_SCHEMAS_LATEST.read().await;
+    if let Some(updated_schema) = read_cache.get(&cache_key) {
+        // ...
+    }
+    // rest of the critical section...
+}