diff --git a/src/storage/src/redis_hashes.cc b/src/storage/src/redis_hashes.cc
index 4d1c9bf6b7..91baee5661 100644
--- a/src/storage/src/redis_hashes.cc
+++ b/src/storage/src/redis_hashes.cc
@@ -209,7 +209,6 @@ Status RedisHashes::HDel(const Slice& key, const std::vector<std::string>& field
   std::string meta_value;
   int32_t del_cnt = 0;
   int32_t version = 0;
-  ScopeRecordLock l(lock_mgr_, key);
   ScopeSnapshot ss(db_, &snapshot);
   read_options.snapshot = snapshot;
   Status s = db_->Get(read_options, handles_[0], key, &meta_value);
@@ -357,7 +356,6 @@ Status RedisHashes::HGetallWithTTL(const Slice& key, std::vector<FieldValue>* fv
 Status RedisHashes::HIncrby(const Slice& key, const Slice& field, int64_t value, int64_t* ret) {
   *ret = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   int32_t version = 0;
   uint32_t statistic = 0;
@@ -428,7 +426,6 @@ Status RedisHashes::HIncrby(const Slice& key, const Slice& field, int64_t value,
 Status RedisHashes::HIncrbyfloat(const Slice& key, const Slice& field, const Slice& by, std::string* new_value) {
   new_value->clear();
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   int32_t version = 0;
   uint32_t statistic = 0;
@@ -606,7 +603,6 @@ Status RedisHashes::HMSet(const Slice& key, const std::vector<FieldValue>& fvs)
   }
 
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   int32_t version = 0;
   std::string meta_value;
@@ -665,7 +661,6 @@ Status RedisHashes::HMSet(const Slice& key, const std::vector<FieldValue>& fvs)
 
 Status RedisHashes::HSet(const Slice& key, const Slice& field, const Slice& value, int32_t* res) {
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   int32_t version = 0;
   uint32_t statistic = 0;
@@ -724,7 +719,6 @@ Status RedisHashes::HSet(const Slice& key, const Slice& field, const Slice& valu
 
 Status RedisHashes::HSetnx(const Slice& key, const Slice& field, const Slice& value, int32_t* ret) {
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   int32_t version = 0;
   std::string meta_value;
@@ -1160,7 +1154,7 @@ Status RedisHashes::PKRScanRange(const Slice& key_start, const Slice& key_end, c
 
 Status RedisHashes::Expire(const Slice& key, int32_t ttl) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
@@ -1183,7 +1177,7 @@ Status RedisHashes::Expire(const Slice& key, int32_t ttl) {
 
 Status RedisHashes::Del(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
@@ -1278,7 +1272,7 @@ bool RedisHashes::PKExpireScan(const std::string& start_key, int32_t min_timesta
 
 Status RedisHashes::Expireat(const Slice& key, int32_t timestamp) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
@@ -1300,7 +1294,7 @@ Status RedisHashes::Expireat(const Slice& key, int32_t timestamp) {
 
 Status RedisHashes::Persist(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value);
diff --git a/src/storage/src/redis_lists.cc b/src/storage/src/redis_lists.cc
index e2d484b3e4..2cc77c56a4 100644
--- a/src/storage/src/redis_lists.cc
+++ b/src/storage/src/redis_lists.cc
@@ -234,7 +234,6 @@ Status RedisLists::LInsert(const Slice& key, const BeforeOrAfter& before_or_afte
                            const std::string& value, int64_t* ret) {
   *ret = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -349,7 +348,6 @@ Status RedisLists::LPop(const Slice& key, int64_t count, std::vector<std::string
   elements->clear();
 
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
@@ -392,7 +390,6 @@ Status RedisLists::LPop(const Slice& key, int64_t count, std::vector<std::string
 Status RedisLists::LPush(const Slice& key, const std::vector<std::string>& values, uint64_t* ret) {
   *ret = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   uint64_t index = 0;
   int32_t version = 0;
@@ -436,7 +433,6 @@ Status RedisLists::LPush(const Slice& key, const std::vector<std::string>& value
 Status RedisLists::LPushx(const Slice& key, const std::vector<std::string>& values, uint64_t* len) {
   *len = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
 
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
@@ -579,7 +575,6 @@ Status RedisLists::LRangeWithTTL(const Slice& key, int64_t start, int64_t stop,
 Status RedisLists::LRem(const Slice& key, int64_t count, const Slice& value, uint64_t* ret) {
   *ret = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -695,7 +690,6 @@ Status RedisLists::LRem(const Slice& key, int64_t count, const Slice& value, uin
 
 Status RedisLists::LSet(const Slice& key, int64_t index, const Slice& value) {
   uint32_t statistic = 0;
-  ScopeRecordLock l(lock_mgr_, key);
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -724,7 +718,7 @@ Status RedisLists::LSet(const Slice& key, int64_t index, const Slice& value) {
 
 Status RedisLists::LTrim(const Slice& key, int64_t start, int64_t stop) {
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
 
   uint32_t statistic = 0;
   std::string meta_value;
@@ -786,7 +780,7 @@ Status RedisLists::RPop(const Slice& key, int64_t count, std::vector<std::string
   elements->clear();
 
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
 
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
@@ -986,7 +980,7 @@ Status RedisLists::RPushx(const Slice& key, const std::vector<std::string>& valu
   *len = 0;
   rocksdb::WriteBatch batch;
 
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -1120,7 +1114,7 @@ Status RedisLists::PKRScanRange(const Slice& key_start, const Slice& key_end, co
 
 Status RedisLists::Expire(const Slice& key, int32_t ttl) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
@@ -1143,7 +1137,7 @@ Status RedisLists::Expire(const Slice& key, int32_t ttl) {
 
 Status RedisLists::Del(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
@@ -1237,7 +1231,7 @@ bool RedisLists::PKExpireScan(const std::string& start_key, int32_t min_timestam
 
 Status RedisLists::Expireat(const Slice& key, int32_t timestamp) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
@@ -1259,7 +1253,7 @@ Status RedisLists::Expireat(const Slice& key, int32_t timestamp) {
 
 Status RedisLists::Persist(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedListsMetaValue parsed_lists_meta_value(&meta_value);
diff --git a/src/storage/src/redis_sets.cc b/src/storage/src/redis_sets.cc
index f76217eb32..c9696b109a 100644
--- a/src/storage/src/redis_sets.cc
+++ b/src/storage/src/redis_sets.cc
@@ -208,7 +208,6 @@ rocksdb::Status RedisSets::SAdd(const Slice& key, const std::vector<std::string>
   }
 
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   int32_t version = 0;
   std::string meta_value;
   rocksdb::Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
@@ -841,7 +840,7 @@ rocksdb::Status RedisSets::SPop(const Slice& key, std::vector<std::string>* memb
 
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
 
   uint64_t start_us = pstd::NowMicros();
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
@@ -935,7 +934,7 @@ rocksdb::Status RedisSets::SRandmember(const Slice& key, int32_t count, std::vec
 
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   std::vector<int32_t> targets;
   std::unordered_set<int32_t> unique;
 
@@ -996,7 +995,7 @@ rocksdb::Status RedisSets::SRandmember(const Slice& key, int32_t count, std::vec
 rocksdb::Status RedisSets::SRem(const Slice& key, const std::vector<std::string>& members, int32_t* ret) {
   *ret = 0;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
 
   int32_t version = 0;
   uint32_t statistic = 0;
@@ -1345,7 +1344,7 @@ rocksdb::Status RedisSets::PKRScanRange(const Slice& key_start, const Slice& key
 
 rocksdb::Status RedisSets::Expire(const Slice& key, int32_t ttl) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   rocksdb::Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
@@ -1368,7 +1367,7 @@ rocksdb::Status RedisSets::Expire(const Slice& key, int32_t ttl) {
 
 rocksdb::Status RedisSets::Del(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   rocksdb::Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
@@ -1462,7 +1461,7 @@ bool RedisSets::PKExpireScan(const std::string& start_key, int32_t min_timestamp
 
 rocksdb::Status RedisSets::Expireat(const Slice& key, int32_t timestamp) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   rocksdb::Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
@@ -1484,7 +1483,7 @@ rocksdb::Status RedisSets::Expireat(const Slice& key, int32_t timestamp) {
 
 rocksdb::Status RedisSets::Persist(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   rocksdb::Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedSetsMetaValue parsed_sets_meta_value(&meta_value);
diff --git a/src/storage/src/redis_strings.cc b/src/storage/src/redis_strings.cc
index dd4c63dbbb..80b1e77f10 100644
--- a/src/storage/src/redis_strings.cc
+++ b/src/storage/src/redis_strings.cc
@@ -162,7 +162,6 @@ Status RedisStrings::PKPatternMatchDel(const std::string& pattern, int32_t* ret)
 Status RedisStrings::Append(const Slice& key, const Slice& value, int32_t* ret) {
   std::string old_value;
   *ret = 0;
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -335,7 +334,6 @@ Status RedisStrings::BitOp(BitOpType op, const std::string& dest_key, const std:
 Status RedisStrings::Decrby(const Slice& key, int64_t value, int64_t* ret) {
   std::string old_value;
   std::string new_value;
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -526,7 +524,6 @@ Status RedisStrings::GetrangeWithValue(const Slice& key, int64_t start_offset, i
 }
 
 Status RedisStrings::GetSet(const Slice& key, const Slice& value, std::string* old_value) {
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(old_value);
@@ -545,7 +542,6 @@ Status RedisStrings::GetSet(const Slice& key, const Slice& value, std::string* o
 Status RedisStrings::Incrby(const Slice& key, int64_t value, int64_t* ret) {
   std::string old_value;
   std::string new_value;
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &old_value);
   char buf[32] = {0};
   if (s.ok()) {
@@ -589,7 +585,6 @@ Status RedisStrings::Incrbyfloat(const Slice& key, const Slice& value, std::stri
   if (StrToLongDouble(value.data(), value.size(), &long_double_by) == -1) {
     return Status::Corruption("Value is not a vaild float");
   }
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -731,7 +726,6 @@ Status RedisStrings::MSetnx(const std::vector<KeyValue>& kvs, int32_t* ret) {
 
 Status RedisStrings::Set(const Slice& key, const Slice& value) {
   StringsValue strings_value(value);
-  ScopeRecordLock l(lock_mgr_, key);
   return db_->Put(default_write_options_, key, strings_value.Encode());
 }
 
@@ -739,7 +733,6 @@ Status RedisStrings::Setxx(const Slice& key, const Slice& value, int32_t* ret, c
   bool not_found = true;
   std::string old_value;
   StringsValue strings_value(value);
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(old_value);
@@ -768,7 +761,6 @@ Status RedisStrings::SetBit(const Slice& key, int64_t offset, int32_t on, int32_
     return Status::InvalidArgument("offset < 0");
   }
 
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, key, &meta_value);
   if (s.ok() || s.IsNotFound()) {
     std::string data_value;
@@ -819,14 +811,14 @@ Status RedisStrings::Setex(const Slice& key, const Slice& value, int32_t ttl) {
   if (s != Status::OK()) {
     return s;
   }
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   return db_->Put(default_write_options_, key, strings_value.Encode());
 }
 
 Status RedisStrings::Setnx(const Slice& key, const Slice& value, int32_t* ret, const int32_t ttl) {
   *ret = 0;
   std::string old_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -857,7 +849,7 @@ Status RedisStrings::Setvx(const Slice& key, const Slice& value, const Slice& ne
                            const int32_t ttl) {
   *ret = 0;
   std::string old_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -889,7 +881,7 @@ Status RedisStrings::Setvx(const Slice& key, const Slice& value, const Slice& ne
 Status RedisStrings::Delvx(const Slice& key, const Slice& value, int32_t* ret) {
   *ret = 0;
   std::string old_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&old_value);
@@ -917,7 +909,7 @@ Status RedisStrings::Setrange(const Slice& key, int64_t start_offset, const Slic
     return Status::InvalidArgument("offset < 0");
   }
 
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &old_value);
   if (s.ok()) {
     int32_t timestamp = 0;
@@ -1154,7 +1146,7 @@ Status RedisStrings::BitPos(const Slice& key, int32_t bit, int64_t start_offset,
 
 Status RedisStrings::PKSetexAt(const Slice& key, const Slice& value, int32_t timestamp) {
   StringsValue strings_value(value);
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   strings_value.set_timestamp(timestamp);
   return db_->Put(default_write_options_, key, strings_value.Encode());
 }
@@ -1273,7 +1265,7 @@ Status RedisStrings::PKRScanRange(const Slice& key_start, const Slice& key_end,
 
 Status RedisStrings::Expire(const Slice& key, int32_t ttl) {
   std::string value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&value);
@@ -1292,7 +1284,7 @@ Status RedisStrings::Expire(const Slice& key, int32_t ttl) {
 
 Status RedisStrings::Del(const Slice& key) {
   std::string value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&value);
@@ -1383,7 +1375,7 @@ bool RedisStrings::PKExpireScan(const std::string& start_key, int32_t min_timest
 
 Status RedisStrings::Expireat(const Slice& key, int32_t timestamp) {
   std::string value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&value);
@@ -1403,7 +1395,7 @@ Status RedisStrings::Expireat(const Slice& key, int32_t timestamp) {
 
 Status RedisStrings::Persist(const Slice& key) {
   std::string value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&value);
@@ -1424,7 +1416,7 @@ Status RedisStrings::Persist(const Slice& key) {
 
 Status RedisStrings::TTL(const Slice& key, int64_t* timestamp) {
   std::string value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &value);
   if (s.ok()) {
     ParsedStringsValue parsed_strings_value(&value);
diff --git a/src/storage/src/redis_zsets.cc b/src/storage/src/redis_zsets.cc
index 4da415901f..a8e68cc5ad 100644
--- a/src/storage/src/redis_zsets.cc
+++ b/src/storage/src/redis_zsets.cc
@@ -216,7 +216,6 @@ Status RedisZSets::ZPopMax(const Slice& key, const int64_t count, std::vector<Sc
   uint32_t statistic = 0;
   score_members->clear();
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -262,7 +261,6 @@ Status RedisZSets::ZPopMin(const Slice& key, const int64_t count, std::vector<Sc
   uint32_t statistic = 0;
   score_members->clear();
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   std::string meta_value;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
@@ -320,7 +318,6 @@ Status RedisZSets::ZAdd(const Slice& key, const std::vector<ScoreMember>& score_
   int32_t version = 0;
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     bool vaild = true;
@@ -483,7 +480,6 @@ Status RedisZSets::ZIncrby(const Slice& key, const Slice& member, double increme
   int32_t version = 0;
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -766,7 +762,7 @@ Status RedisZSets::ZRem(const Slice& key, const std::vector<std::string>& member
 
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -815,7 +811,7 @@ Status RedisZSets::ZRemrangebyrank(const Slice& key, int32_t start, int32_t stop
   uint32_t statistic = 0;
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -871,7 +867,7 @@ Status RedisZSets::ZRemrangebyscore(const Slice& key, double min, double max, bo
   uint32_t statistic = 0;
   std::string meta_value;
   rocksdb::WriteBatch batch;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -1415,7 +1411,7 @@ Status RedisZSets::ZRemrangebylex(const Slice& key, const Slice& min, const Slic
 
   ScopeSnapshot ss(db_, &snapshot);
   read_options.snapshot = snapshot;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
 
   bool left_no_limit = min.compare("-") == 0;
   bool right_not_limit = max.compare("+") == 0;
@@ -1480,7 +1476,7 @@ Status RedisZSets::ZRemrangebylex(const Slice& key, const Slice& min, const Slic
 
 Status RedisZSets::Expire(const Slice& key, int32_t ttl) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -1502,7 +1498,7 @@ Status RedisZSets::Expire(const Slice& key, int32_t ttl) {
 
 Status RedisZSets::Del(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -1596,7 +1592,7 @@ bool RedisZSets::PKExpireScan(const std::string& start_key, int32_t min_timestam
 
 Status RedisZSets::Expireat(const Slice& key, int32_t timestamp) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);
@@ -1797,7 +1793,7 @@ Status RedisZSets::PKRScanRange(const Slice& key_start, const Slice& key_end, co
 
 Status RedisZSets::Persist(const Slice& key) {
   std::string meta_value;
-  ScopeRecordLock l(lock_mgr_, key);
+  ;
   Status s = db_->Get(default_read_options_, handles_[0], key, &meta_value);
   if (s.ok()) {
     ParsedZSetsMetaValue parsed_zsets_meta_value(&meta_value);