diff --git a/mittest/mtlenv/mock_tenant_module_env.h b/mittest/mtlenv/mock_tenant_module_env.h
index d275c769fe..256390b528 100644
--- a/mittest/mtlenv/mock_tenant_module_env.h
+++ b/mittest/mtlenv/mock_tenant_module_env.h
@@ -705,6 +705,7 @@ int MockTenantModuleEnv::init()
       MTL_BIND2(mtl_new_default, table::ObHTableLockMgr::mtl_init, nullptr, nullptr, nullptr, table::ObHTableLockMgr::mtl_destroy);
       MTL_BIND2(mtl_new_default, omt::ObTenantSrs::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default);
       MTL_BIND2(mtl_new_default, table::ObTableApiSessPoolMgr::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default);
+      MTL_BIND2(mtl_new_default, storage::ObTabletMemtableMgrPool::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default);
     }
     if (OB_FAIL(ret)) {
 
diff --git a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
index eaa8e82144..319ddcb547 100644
--- a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
+++ b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
@@ -1245,8 +1245,6 @@ TEST_F(TestTenantMetaMemMgr, test_replace_tablet)
   ASSERT_TRUE(nullptr != tablet);
   ASSERT_TRUE(tablet->pointer_hdl_.is_valid());
 
-  ObIMemtableMgr *memtable_mgr = tablet->get_memtable_mgr();
-
   handle.reset();
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(0, t3m_.tablet_buffer_pool_.inner_used_num_);
@@ -1264,8 +1262,6 @@ TEST_F(TestTenantMetaMemMgr, test_replace_tablet)
 
   tablet = handle.get_obj();
   ASSERT_TRUE(nullptr != tablet);
-  ASSERT_TRUE(nullptr != tablet->get_memtable_mgr());
-  ASSERT_TRUE(memtable_mgr == tablet->get_memtable_mgr());
 
   addr.first_id_ = 1;
   addr.second_id_ = 4;
diff --git a/mittest/mtlenv/storage/test_trans.cpp b/mittest/mtlenv/storage/test_trans.cpp
index 9a980829b1..335fce6ffd 100644
--- a/mittest/mtlenv/storage/test_trans.cpp
+++ b/mittest/mtlenv/storage/test_trans.cpp
@@ -259,10 +259,11 @@ TEST_F(TestTrans, basic)
   ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
   ObTabletHandle tablet_handle;
   ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet_svr()->get_tablet(tablet_id, tablet_handle, 0));
-  ObIMemtableMgr *mt_mgr = tablet_handle.get_obj()->get_memtable_mgr();
-  ASSERT_EQ(1, mt_mgr->get_memtable_count_());
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->get_protected_memtable_mgr_handle(protected_handle));
+  ASSERT_EQ(1, protected_handle->memtable_mgr_handle_.get_memtable_mgr()->get_memtable_count_());
   ObTableHandleV2 mt_handle;
-  ASSERT_EQ(OB_SUCCESS, mt_mgr->get_active_memtable(mt_handle));
+  ASSERT_EQ(OB_SUCCESS, protected_handle->get_active_memtable(mt_handle));
   memtable::ObMemtable *mt;
   ASSERT_EQ(OB_SUCCESS, mt_handle.get_data_memtable(mt));
 
diff --git a/mittest/simple_server/test_mds_recover.cpp b/mittest/simple_server/test_mds_recover.cpp
index 352c790ca2..e671d6b0db 100644
--- a/mittest/simple_server/test_mds_recover.cpp
+++ b/mittest/simple_server/test_mds_recover.cpp
@@ -172,7 +172,7 @@ void do_flush_mds_table(share::ObLSID ls_id, ObTabletID tablet_id)
   ObTabletPointer *tablet_pointer = pointer_handle.get_resource_ptr();
   // 4. 做flush动作
   mds::MdsTableHandle handle;
-  ASSERT_EQ(OB_SUCCESS, tablet_pointer->get_mds_table(handle));
+  ASSERT_EQ(OB_SUCCESS, tablet_pointer->get_mds_table(tablet_id, handle));
   ASSERT_EQ(OB_SUCCESS, handle.flush(share::SCN::max_scn()));
   ASSERT_EQ(true, handle.p_mds_table_base_->flushing_scn_.is_valid());
   // 5. 等flush完成
diff --git a/src/observer/ob_rpc_processor_simple.cpp b/src/observer/ob_rpc_processor_simple.cpp
index fa4dcd3053..0771b5bdc6 100644
--- a/src/observer/ob_rpc_processor_simple.cpp
+++ b/src/observer/ob_rpc_processor_simple.cpp
@@ -1024,7 +1024,6 @@ int ObDumpMemtableP::process()
       ObLSService* ls_svr = nullptr;
       ObTabletHandle tablet_handle;
       ObLSHandle ls_handle;
-      ObIMemtableMgr *memtable_mgr = nullptr;
       common::ObSEArray<ObTableHandleV2, 7> tables_handle;
 
       if (OB_ISNULL(ls_svr = MTL(ObLSService*))) {
@@ -1047,11 +1046,8 @@ int ObDumpMemtableP::process()
       } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
         ret = OB_ERR_UNEXPECTED;
         SERVER_LOG(WARN, "invalid tablet handle", K(ret), K(tablet_handle));
-      } else if (OB_ISNULL(memtable_mgr = tablet_handle.get_obj()->get_memtable_mgr())) {
-        ret = OB_ERR_UNEXPECTED;
-        SERVER_LOG(WARN, "memtable mgr is null", K(ret));
-      } else if (OB_FAIL(memtable_mgr->get_all_memtables(tables_handle))) {
-        SERVER_LOG(WARN, "fail to get all memtables for log stream", K(ret));
+      } else if (OB_FAIL(tablet_handle.get_obj()->get_all_memtables(tables_handle))) {
+        LOG_WARN("failed to get all memtable", K(ret), KPC(tablet_handle.get_obj()));
       } else {
         memtable::ObMemtable *mt;
         mkdir("/tmp/dump_memtable/", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
diff --git a/src/observer/omt/ob_multi_tenant.cpp b/src/observer/omt/ob_multi_tenant.cpp
index d55b83bef7..09d490b231 100644
--- a/src/observer/omt/ob_multi_tenant.cpp
+++ b/src/observer/omt/ob_multi_tenant.cpp
@@ -142,6 +142,7 @@
 #include "storage/access/ob_empty_read_bucket.h"
 #include "observer/table/ttl/ob_ttl_service.h"
 #include "sql/dtl/ob_dtl_interm_result_manager.h"
+#include "storage/tablet/ob_tablet_memtable_mgr.h"
 #ifdef ERRSIM
 #include "share/errsim_module/ob_tenant_errsim_module_mgr.h"
 #include "share/errsim_module/ob_tenant_errsim_event_mgr.h"
@@ -553,6 +554,7 @@ int ObMultiTenant::init(ObAddr myaddr,
     MTL_BIND2(mtl_new_default, ObOptStatMonitorManager::mtl_init, ObOptStatMonitorManager::mtl_start, ObOptStatMonitorManager::mtl_stop, ObOptStatMonitorManager::mtl_wait, mtl_destroy_default);
     MTL_BIND2(mtl_new_default, ObTenantSrs::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default);
     MTL_BIND2(mtl_new_default, table::ObTableApiSessPoolMgr::mtl_init, mtl_start_default, mtl_stop_default, mtl_wait_default, mtl_destroy_default);
+    MTL_BIND2(mtl_new_default, storage::ObTabletMemtableMgrPool::mtl_init, nullptr, nullptr, nullptr, mtl_destroy_default);
   }
 
   if (OB_SUCC(ret)) {
diff --git a/src/observer/virtual_table/ob_all_virtual_memstore_info.cpp b/src/observer/virtual_table/ob_all_virtual_memstore_info.cpp
index c8950076d3..d297e9be2d 100644
--- a/src/observer/virtual_table/ob_all_virtual_memstore_info.cpp
+++ b/src/observer/virtual_table/ob_all_virtual_memstore_info.cpp
@@ -155,11 +155,8 @@ int ObAllVirtualMemstoreInfo::get_next_memtable(memtable::ObMemtable *&mt)
       } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
         ret = OB_ERR_UNEXPECTED;
         SERVER_LOG(WARN, "invalid tablet handle", K(ret), K(tablet_handle));
-      } else if (OB_ISNULL(memtable_mgr = tablet_handle.get_obj()->get_memtable_mgr())) {
-        ret = OB_ERR_UNEXPECTED;
-        SERVER_LOG(WARN, "memtable mgr is null", K(ret));
-      } else if (OB_FAIL(memtable_mgr->get_all_memtables(tables_handle_))) {
-        SERVER_LOG(WARN, "fail to get all memtables for log stream", K(ret));
+      } else if (OB_FAIL(tablet_handle.get_obj()->get_all_memtables(tables_handle_))) {
+        SERVER_LOG(WARN, "failed to get_memtable_mgr for get all memtable", K(ret), KPC(tablet_handle.get_obj()));
       }
     } else if (OB_FAIL(tables_handle_.at(memtable_array_pos_++).get_data_memtable(mt))) {
       // get next memtable
diff --git a/src/share/rc/ob_tenant_base.h b/src/share/rc/ob_tenant_base.h
index d22d6c9fdd..b0dfba7a1c 100755
--- a/src/share/rc/ob_tenant_base.h
+++ b/src/share/rc/ob_tenant_base.h
@@ -91,6 +91,7 @@ class ObTenantMdsService;
   class ObTableScanIterator;
   class ObTenantCGReadInfoMgr;
   class ObEmptyReadBucket;
+  class ObTabletMemtableMgrPool;
 } // namespace storage
 namespace transaction {
   class ObTenantWeakReadService; // 租户弱一致性读服务
@@ -333,7 +334,8 @@ using ObTableScanIteratorObjPool = common::ObServerObjectPool<oceanbase::storage
       omt::ObTenantSrs*,                            \
       table::ObHTableLockMgr*,                      \
       table::ObTTLService*,                         \
-      table::ObTableApiSessPoolMgr*                \
+      table::ObTableApiSessPoolMgr*,                \
+      storage::ObTabletMemtableMgrPool*             \
   )
 
 
diff --git a/src/storage/CMakeLists.txt b/src/storage/CMakeLists.txt
index 1ab11feaa4..1222bd6552 100644
--- a/src/storage/CMakeLists.txt
+++ b/src/storage/CMakeLists.txt
@@ -552,6 +552,7 @@ ob_set_subtarget(ob_storage common
   ob_value_row_iterator.cpp
   ob_common_id_utils.cpp
   ob_tenant_tablet_stat_mgr.cpp
+  ob_protected_memtable_mgr_handle.cpp
 )
 
 ob_set_subtarget(ob_storage common_mixed
diff --git a/src/storage/compaction/ob_basic_tablet_merge_ctx.cpp b/src/storage/compaction/ob_basic_tablet_merge_ctx.cpp
index 862bdff5d5..9348d5e1ae 100644
--- a/src/storage/compaction/ob_basic_tablet_merge_ctx.cpp
+++ b/src/storage/compaction/ob_basic_tablet_merge_ctx.cpp
@@ -535,7 +535,7 @@ bool ObBasicTabletMergeCtx::need_swap_tablet(const ObTablet &tablet,
                                              const int64_t row_count,
                                              const int64_t macro_count)
 {
-  bool bret = tablet.get_memtable_mgr()->has_memtable()
+  bool bret = tablet.has_memtable()
     && (row_count >= LARGE_VOLUME_DATA_ROW_COUNT_THREASHOLD
       || macro_count >= LARGE_VOLUME_DATA_MACRO_COUNT_THREASHOLD);
 #ifdef ERRSIM
diff --git a/src/storage/compaction/ob_partition_merge_policy.cpp b/src/storage/compaction/ob_partition_merge_policy.cpp
index d7393c8449..cc1d6feb1b 100644
--- a/src/storage/compaction/ob_partition_merge_policy.cpp
+++ b/src/storage/compaction/ob_partition_merge_policy.cpp
@@ -236,17 +236,14 @@ int ObPartitionMergePolicy::get_mini_merge_tables(
   if (OB_UNLIKELY(MINI_MERGE != merge_type)) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), "merge_type", merge_type_to_str(merge_type));
-  } else if (OB_UNLIKELY(nullptr == tablet.get_memtable_mgr())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("get unexpected null memtable mgr from tablet or invalid table store", K(ret), K(tablet));
   } else if (is_sstable_count_not_safe(tablet.get_minor_table_count())) {
     ret = OB_SIZE_OVERFLOW;
     LOG_ERROR("Too many sstables, delay mini merge until sstable count falls below MAX_SSTABLE_CNT",
               K(ret), K(tablet));
     // add compaction diagnose info
     ObPartitionMergePolicy::diagnose_table_count_unsafe(MINI_MERGE, ObDiagnoseTabletType::TYPE_MINI_MERGE, tablet);
-  } else if (OB_FAIL(tablet.get_memtable_mgr()->get_all_memtables(memtable_handles))) {
-    LOG_WARN("failed to get all memtables from memtable mgr", K(ret));
+  } else if (OB_FAIL(tablet.get_all_memtables(memtable_handles))) {
+    LOG_WARN("failed to get all memtable", K(ret), K(tablet));
   } else if (OB_FAIL(get_neighbour_freeze_info(merge_inc_base_version,
                                                tablet.get_last_major_snapshot_version(),
                                                freeze_info,
@@ -1001,6 +998,7 @@ int ObPartitionMergePolicy::check_need_medium_merge(
   const bool is_tablet_data_status_complete = tablet.get_tablet_meta().ha_status_.is_data_status_complete();
 
   bool ls_weak_read_ts_ready = ObTenantTabletScheduler::check_weak_read_ts_ready(medium_snapshot, ls);
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (0 >= last_major_snapshot_version) {
     // no major, no medium
@@ -1011,18 +1009,16 @@ int ObPartitionMergePolicy::check_need_medium_merge(
         && ls_weak_read_ts_ready) {
       can_merge = tablet.get_snapshot_version() >= medium_snapshot;
       if (!can_merge) {
-        ObTabletMemtableMgr *memtable_mgr = nullptr;
         ObTableHandleV2 memtable_handle;
         memtable::ObMemtable *last_frozen_memtable = nullptr;
-        if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr *>(tablet.get_memtable_mgr()))) {
-          ret = OB_ERR_UNEXPECTED;
-          LOG_WARN("memtable mgr is unexpected null", K(ret), K(tablet));
-        } else if (OB_FAIL(memtable_mgr->get_last_frozen_memtable(memtable_handle))) {
+        if (OB_FAIL(tablet.get_protected_memtable_mgr_handle(protected_handle))) {
+          LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), K(tablet));
+        } else if (OB_FAIL(protected_handle->get_last_frozen_memtable(memtable_handle))) {
           if (OB_ENTRY_NOT_EXIST == ret) { // no frozen memtable, need force freeze
             need_force_freeze = true;
             ret = OB_SUCCESS;
           } else {
-            LOG_WARN("failed to get last frozen memtable", K(ret));
+            LOG_WARN("failed to get last frozen memtable", K(ret), K(tablet));
           }
         } else if (OB_FAIL(memtable_handle.get_data_memtable(last_frozen_memtable))) {
           LOG_WARN("failed to get last frozen memtable", K(ret));
diff --git a/src/storage/high_availability/ob_tablet_backfill_tx.cpp b/src/storage/high_availability/ob_tablet_backfill_tx.cpp
index 274c5b33ee..cdcc85404d 100644
--- a/src/storage/high_availability/ob_tablet_backfill_tx.cpp
+++ b/src/storage/high_availability/ob_tablet_backfill_tx.cpp
@@ -562,12 +562,8 @@ int ObTabletBackfillTXTask::get_backfill_tx_memtables_(
       memtables.reset();
       table_array.reset();
       bool is_memtable_ready = true;
-      ObIMemtableMgr *memtable_mgr = nullptr;
-      if (OB_ISNULL(memtable_mgr = tablet->get_memtable_mgr())) {
-        ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("memtable mgr should not be NULL", K(ret), KP(memtable_mgr));
-      } else if (OB_FAIL(memtable_mgr->get_all_memtables(memtables))) {
-        LOG_WARN("failed to get all memtables", K(ret), KPC(tablet));
+      if (OB_FAIL(tablet->get_all_memtables(memtables))) {
+        LOG_WARN("failed to get_memtable_mgr for get all memtable", K(ret), KPC(tablet));
       } else if (memtables.empty()) {
         break;
       } else {
diff --git a/src/storage/high_availability/ob_transfer_backfill_tx.cpp b/src/storage/high_availability/ob_transfer_backfill_tx.cpp
index 26a365096c..9234febd03 100644
--- a/src/storage/high_availability/ob_transfer_backfill_tx.cpp
+++ b/src/storage/high_availability/ob_transfer_backfill_tx.cpp
@@ -1287,15 +1287,11 @@ int ObTransferReplaceTableTask::check_src_memtable_is_empty_(
 {
   int ret = OB_SUCCESS;
   ObArray<ObTableHandleV2> memtables;
-  ObIMemtableMgr *memtable_mgr = nullptr;
   if (OB_ISNULL(tablet) || !transfer_scn.is_valid()) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("tablet should not be nullptr.", KR(ret), K(transfer_scn), KPC(this));
-  } else if (OB_ISNULL(memtable_mgr = tablet->get_memtable_mgr())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr should not be NULL", K(ret), KP(memtable_mgr));
-  } else if (OB_FAIL(memtable_mgr->get_all_memtables(memtables))) {
-    LOG_WARN("failed to get all memtables", K(ret), KPC(tablet));
+  } else if (OB_FAIL(tablet->get_all_memtables(memtables))) {
+    LOG_WARN("failed to get_memtable_mgr for get all memtable", K(ret), KPC(tablet));
   } else if (!memtables.empty()) {
     for (int64_t i = 0; OB_SUCC(ret) && i < memtables.count(); ++i) {
       ObITable *table = memtables.at(i).get_table();
diff --git a/src/storage/high_availability/ob_transfer_struct.cpp b/src/storage/high_availability/ob_transfer_struct.cpp
index 8fe78724ee..b894c6d709 100644
--- a/src/storage/high_availability/ob_transfer_struct.cpp
+++ b/src/storage/high_availability/ob_transfer_struct.cpp
@@ -331,7 +331,6 @@ int ObTXTransferUtils::set_tablet_freeze_flag(storage::ObLS &ls, ObTablet *table
 {
   MDS_TG(10_ms);
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
   ObArray<ObTableHandleV2> memtables;
   ObTabletID tablet_id = tablet->get_tablet_meta().tablet_id_;
   SCN weak_read_scn;
@@ -348,11 +347,8 @@ int ObTXTransferUtils::set_tablet_freeze_flag(storage::ObLS &ls, ObTablet *table
   } else if (ObScnRange::MIN_SCN == weak_read_scn) {
     ret = OB_EAGAIN;
     LOG_WARN("weak read service not inited, need to wait for weak read scn to advance", K(ret), K(ls_id), K(weak_read_scn));
-  } else if (OB_ISNULL(memtable_mgr = tablet->get_memtable_mgr())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr should not be NULL", K(ret), KP(memtable_mgr));
-  } else if (CLICK_FAIL(memtable_mgr->get_all_memtables(memtables))) {
-    LOG_WARN("failed to get all memtables", K(ret), K(tablet_id));
+  } else if (OB_FAIL(tablet->get_all_memtables(memtables))) {
+    LOG_WARN("failed to get_memtable_mgr for get all memtable", K(ret), KPC(tablet));
   } else {
     CLICK();
     for (int64_t i = 0; OB_SUCC(ret) && i < memtables.count(); ++i) {
diff --git a/src/storage/ls/ob_freezer.cpp b/src/storage/ls/ob_freezer.cpp
index 27200552b9..7c97bf494a 100644
--- a/src/storage/ls/ob_freezer.cpp
+++ b/src/storage/ls/ob_freezer.cpp
@@ -659,11 +659,11 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
   share::ObLSID ls_id = get_ls_id();
   ObTabletHandle handle;
   ObTablet *tablet = nullptr;
-  ObTabletMemtableMgr *memtable_mgr = nullptr;
   ObTableHandleV2 frozen_memtable_handle;
   SCN freeze_snapshot_version;
   FLOG_INFO("[Freezer] tablet_freeze start", K(ret), K(ls_id), K(tablet_id));
   int64_t start_time = ObTimeUtility::current_time();
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   ObTabletFreezeGuard guard(*this, true /* try guard */);
   if (IS_NOT_INIT) {
@@ -702,9 +702,9 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
       TRANS_LOG(WARN, "[Freezer] fail to get tablet", K(ret), K(ls_id), K(tablet_id));
       stat_.add_diagnose_info("fail to get tablet");
     } else if (FALSE_IT(tablet = handle.get_obj())) {
-    } else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr*>(tablet->get_memtable_mgr()))) {
-      TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(ls_id), K(tablet_id));
-    } else if (OB_FAIL(memtable_mgr->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
+    } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+      LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+    } else if (OB_FAIL(protected_handle->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
       if (ret == OB_ENTRY_NOT_EXIST) {
         ret = OB_SUCCESS;
         TRANS_LOG(INFO, "[Freezer] no need to freeze", K(ret),
@@ -749,9 +749,9 @@ int ObFreezer::tablet_freeze_with_rewrite_meta(const ObTabletID &tablet_id)
   share::ObLSID ls_id = get_ls_id();
   ObTabletHandle tablet_handle;
   ObTablet *tablet = nullptr;
-  ObTabletMemtableMgr *memtable_mgr = nullptr;
   ObTableHandleV2 frozen_memtable_handle;
   SCN freeze_snapshot_version;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
   FLOG_INFO("[Freezer] tablet_freeze_with_rewrite_meta start", K(ret), K(ls_id), K(tablet_id));
   int64_t start_time = ObTimeUtility::current_time();
 
@@ -789,12 +789,12 @@ int ObFreezer::tablet_freeze_with_rewrite_meta(const ObTabletID &tablet_id)
       TRANS_LOG(WARN, "[Freezer] fail to get tablet for freeze", K(ret), K(ls_id), K(tablet_id));
       stat_.add_diagnose_info("fail to get tablet");
     } else if (FALSE_IT(tablet = tablet_handle.get_obj())) {
-    } else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr*>(tablet->get_memtable_mgr()))) {
-      TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(ls_id), K(tablet_id));
-    } else if (OB_FAIL(memtable_mgr->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
+    } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+      LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+    } else if (OB_FAIL(protected_handle->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
       if (ret == OB_ENTRY_NOT_EXIST) {
         ret = OB_SUCCESS;
-        if (!memtable_mgr->has_memtable()) {
+        if (!tablet->has_memtable()) {
           // We need trigger a dag to rewrite the snapshot version of tablet
           // meta for the major merge and medium merge. While the implementation
           // need pay much attentio.
@@ -814,6 +814,7 @@ int ObFreezer::tablet_freeze_with_rewrite_meta(const ObTabletID &tablet_id)
           param.tablet_id_ = tablet_id;
           param.skip_get_tablet_ = true;
 
+          ObProtectedMemtableMgrHandle *protected_handle = NULL;
           ObTabletMiniMergeDag tmp_mini_dag;
           bool is_exist = false;
           if (OB_FAIL(tmp_mini_dag.init_by_param(&param))) {
@@ -826,7 +827,9 @@ int ObFreezer::tablet_freeze_with_rewrite_meta(const ObTabletID &tablet_id)
             LOG_WARN("exist running mini compaction dag, try later", K(ret), K(ls_id), K(tablet_id));
           } else if (OB_FAIL(get_ls_tablet_svr()->update_tablet_snapshot_version(tablet_id, freeze_snapshot_version.get_val_for_tx()))) {
             LOG_WARN("failed to update tablet snapshot version", K(ret), K(ls_id), K(tablet_id), K(freeze_snapshot_version));
-          } else if (memtable_mgr->get_medium_info_recorder().get_max_saved_version() >= freeze_snapshot_version.get_val_for_tx()) {
+          } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+            LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+          } else if (protected_handle->get_max_saved_version_from_medium_info_recorder() >= freeze_snapshot_version.get_val_for_tx()) {
             int tmp_ret = OB_SUCCESS;
             if (OB_TMP_FAIL(compaction::ObTenantTabletScheduler::schedule_merge_dag(
                   ls_id,
@@ -958,10 +961,10 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
   share::ObLSID ls_id = get_ls_id();
   ObTabletHandle handle;
   ObTablet *tablet = nullptr;
-  ObTabletMemtableMgr *memtable_mgr = nullptr;
   SCN freeze_snapshot_version;
   FLOG_INFO("[Freezer] tablet_freeze_for_replace_tablet_meta start", K(ret), K(ls_id), K(tablet_id));
   int64_t start_time = ObTimeUtility::current_time();
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   ObTabletFreezeGuard guard(*this, true /* try guard */);
   if (IS_NOT_INIT) {
@@ -999,9 +1002,9 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
       TRANS_LOG(WARN, "[Freezer] fail to get tablet", K(ret), K(ls_id), K(tablet_id));
       stat_.add_diagnose_info("fail to get tablet");
     } else if (FALSE_IT(tablet = handle.get_obj())) {
-    } else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr*>(tablet->get_memtable_mgr()))) {
-      TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(ls_id), K(tablet_id));
-    } else if (OB_FAIL(memtable_mgr->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
+    } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+      LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+    } else if (OB_FAIL(protected_handle->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
       if (ret == OB_ENTRY_NOT_EXIST) {
         ret = OB_SUCCESS;
         TRANS_LOG(INFO, "[Freezer] no need to freeze", K(ret),
@@ -1110,13 +1113,13 @@ int ObFreezer::batch_tablet_freeze_(const ObIArray<ObTabletID> &tablet_ids, ObFu
   int ret = OB_SUCCESS;
   ObTableHandleArray memtable_handles;
   need_freeze= true;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   for (int i = 0; i < tablet_ids.count() && OB_SUCC(ret); ++i) {
     const ObTabletID &tablet_id = tablet_ids.at(i);
     ObTabletHandle handle;
     ObTablet *tablet = nullptr;
     ObTableHandleV2 frozen_memtable_handle;
-    ObTabletMemtableMgr *memtable_mgr = nullptr;
     if (OB_FAIL(get_ls_tablet_svr()->get_tablet(tablet_id,
                                                 handle,
                                                 ObTabletCommon::DEFAULT_GET_TABLET_NO_WAIT,
@@ -1124,9 +1127,9 @@ int ObFreezer::batch_tablet_freeze_(const ObIArray<ObTabletID> &tablet_ids, ObFu
       TRANS_LOG(WARN, "[Freezer] fail to get tablet", K(ret), K(tablet_id));
       stat_.add_diagnose_info("fail to get tablet");
     } else if (FALSE_IT(tablet = handle.get_obj())) {
-    } else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr*>(tablet->get_memtable_mgr()))) {
-      TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(tablet_id));
-    } else if (OB_FAIL(memtable_mgr->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
+    } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+      LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+    } else if (OB_FAIL(protected_handle->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
       if (ret == OB_ENTRY_NOT_EXIST) {
         ret = OB_SUCCESS;
         TRANS_LOG(INFO, "[Freezer] no need to freeze since there is no active memtable", K(ret),
@@ -1425,13 +1428,14 @@ int ObFreezer::create_memtable_if_no_active_memtable(ObTablet *tablet)
 {
   int ret = OB_SUCCESS;
   share::ObLSID ls_id = get_ls_id();
-  ObTabletMemtableMgr *memtable_mgr = nullptr;
   ObTableHandleV2 last_frozen_memtable_handle;
   memtable::ObMemtable *last_frozen_memtable = nullptr;
   const common::ObTabletID &tablet_id = tablet->get_tablet_meta().tablet_id_;
   SCN clog_checkpoint_scn = tablet->get_tablet_meta().clog_checkpoint_scn_;
   int64_t schema_version = 0;
   SCN max_callbacked_scn = SCN::min_scn();
+  bool has_active_memtable = false;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
@@ -1441,13 +1445,13 @@ int ObFreezer::create_memtable_if_no_active_memtable(ObTablet *tablet)
   } else if (max_callbacked_scn < clog_checkpoint_scn) {
     ret = OB_NO_NEED_UPDATE;
     LOG_WARN("[Freezer] cannot create memtable because max_callbacked_scn < clog_checkpoint_scn", K(ret), K(ls_id), K(tablet_id));
-  } else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr *>(tablet->get_memtable_mgr()))) {
-    LOG_WARN("[Freezer] memtable mgr should not be null", K(ret), K(ls_id), K(tablet_id));
-  } else if (memtable_mgr->has_active_memtable()) {
+  } else if (OB_FAIL(tablet->get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet));
+  } else if (protected_handle->has_active_memtable()) {
     LOG_INFO("[Freezer] no need to create an active memtable", K(ret), K(ls_id), K(tablet_id));
   } else { // create a new memtable since there is no active memtable
     // get schema_version
-    if (OB_FAIL(memtable_mgr->get_last_frozen_memtable(last_frozen_memtable_handle))) {
+    if (OB_FAIL(protected_handle->get_last_frozen_memtable(last_frozen_memtable_handle))) {
       if (OB_ENTRY_NOT_EXIST != ret) {
         LOG_WARN("[Freezer] fail to get last frozen memtable", K(ret), K(ls_id), K(tablet_id));
       } else {
diff --git a/src/storage/meta_mem/ob_tablet_pointer.cpp b/src/storage/meta_mem/ob_tablet_pointer.cpp
index ff83a5bb73..d2c43aa544 100644
--- a/src/storage/meta_mem/ob_tablet_pointer.cpp
+++ b/src/storage/meta_mem/ob_tablet_pointer.cpp
@@ -42,7 +42,7 @@ ObTabletPointer::ObTabletPointer()
     obj_(),
     ls_handle_(),
     ddl_kv_mgr_handle_(),
-    memtable_mgr_handle_(),
+    protected_memtable_mgr_handle_(),
     ddl_info_(),
     initial_state_(true),
     ddl_kv_mgr_lock_(),
@@ -50,7 +50,7 @@ ObTabletPointer::ObTabletPointer()
     old_version_chain_(nullptr)
 {
 #if defined(__x86_64__) && !defined(ENABLE_OBJ_LEAK_CHECK)
-  static_assert(sizeof(ObTabletPointer) == 264, "The size of ObTabletPointer will affect the meta memory manager, and the necessity of adding new fields needs to be considered.");
+  static_assert(sizeof(ObTabletPointer) == 280, "The size of ObTabletPointer will affect the meta memory manager, and the necessity of adding new fields needs to be considered.");
 #endif
 }
 
@@ -60,7 +60,7 @@ ObTabletPointer::ObTabletPointer(
   : phy_addr_(),
     obj_(),
     ls_handle_(ls_handle),
-    memtable_mgr_handle_(memtable_mgr_handle),
+    protected_memtable_mgr_handle_(memtable_mgr_handle),
     ddl_info_(),
     initial_state_(true),
     ddl_kv_mgr_lock_(),
@@ -82,7 +82,7 @@ void ObTabletPointer::reset()
     ddl_kv_mgr_handle_.reset();
   }
   mds_table_handler_.reset();
-  memtable_mgr_handle_.reset();
+  protected_memtable_mgr_handle_.reset();
   ddl_info_.reset();
   initial_state_ = true;
   ATOMIC_STORE(&initial_state_, true);
@@ -296,7 +296,6 @@ int ObTabletPointer::get_attr_for_obj(ObTablet *tablet)
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("log handler is null", K(ret), KP(log_handler));
   } else {
-    tablet->memtable_mgr_ = memtable_mgr_handle_.get_memtable_mgr();
     tablet->log_handler_ = log_handler;
   }
 
@@ -389,7 +388,7 @@ int ObTabletPointer::deep_copy(char *buf, const int64_t buf_len, ObTabletPointer
     if (OB_SUCC(ret)) {
       pvalue->ls_handle_ = ls_handle_;
       pvalue->ddl_kv_mgr_handle_ = ddl_kv_mgr_handle_;
-      pvalue->memtable_mgr_handle_ = memtable_mgr_handle_;
+      pvalue->protected_memtable_mgr_handle_ = protected_memtable_mgr_handle_;
       pvalue->ddl_info_ = ddl_info_;
       pvalue->initial_state_ = initial_state_;
       pvalue->mds_table_handler_ = mds_table_handler_;// src ObTabletPointer will destroy soon
@@ -480,23 +479,19 @@ int ObTabletPointer::remove_ddl_kv_mgr(const ObDDLKvMgrHandle &ddl_kv_mgr_handle
   return ret;
 }
 
-int ObTabletPointer::get_mds_table(mds::MdsTableHandle &handle, bool not_exist_create)
+int ObTabletPointer::get_mds_table(const ObTabletID &tablet_id,
+    mds::MdsTableHandle &handle,
+    bool not_exist_create)
 {
   int ret = OB_SUCCESS;
   if (!ls_handle_.is_valid()) {
     ret = OB_NOT_INIT;
     LOG_ERROR("invalid ls_handle_, maybe not init yet", K(ret));
-  } else if (!memtable_mgr_handle_.is_valid()) {
-    ret = OB_NOT_INIT;
-    LOG_ERROR("invalid memtable_mgr_handle_, maybe not init yet", K(ret));
-  } else if (OB_ISNULL(ls_handle_.get_ls())) {
-    ret = OB_BAD_NULL_ERROR;
-    LOG_ERROR("ls in handle is nullptr", K(ret));
-  } else if (OB_ISNULL(memtable_mgr_handle_.get_memtable_mgr())) {
-    ret = OB_BAD_NULL_ERROR;
-    LOG_ERROR("memtable mgr in handle is nullptr", K(ret));
+  } else if (!tablet_id.is_valid()) {
+    ret = OB_ERR_UNEXPECTED;
+    STORAGE_LOG(WARN, "tablet_id is invalid", K(ret));
   } else if (OB_FAIL(mds_table_handler_.get_mds_table_handle(handle,
-                                                             memtable_mgr_handle_.get_memtable_mgr()->get_tablet_id(),
+                                                             tablet_id,
                                                              ls_handle_.get_ls()->get_ls_id(),
                                                              not_exist_create,
                                                              this))) {
@@ -532,19 +527,13 @@ void ObTabletPointer::mark_mds_table_deleted()
   return mds_table_handler_.mark_removed_from_t3m(this);
 }
 
-int ObTabletPointer::release_memtable_and_mds_table_for_ls_offline()
+int ObTabletPointer::release_memtable_and_mds_table_for_ls_offline(const ObTabletID &tablet_id)
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = memtable_mgr_handle_.get_memtable_mgr();
   mds::MdsTableHandle mds_table;
-  if (OB_ISNULL(memtable_mgr)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr is null", K(ret));
-  } else if (OB_FAIL(memtable_mgr->release_memtables())) {
-    LOG_WARN("failed to release memtables", K(ret));
-  } else if (OB_FAIL(memtable_mgr->reset_storage_recorder())) {
-    LOG_WARN("failed to destroy storage recorder", K(ret), KPC(memtable_mgr));
-  } else if (OB_FAIL(get_mds_table(mds_table, false/*not_exist_create*/))) {
+  if (OB_FAIL(protected_memtable_mgr_handle_.reset())) {
+    LOG_WARN("failed to reset protected_memtable_mgr_handle", K(ret));
+  } else if (OB_FAIL(get_mds_table(tablet_id, mds_table, false/*not_exist_create*/))) {
     if (OB_ENTRY_NOT_EXIST == ret) {
       ret = OB_SUCCESS;
     } else {
diff --git a/src/storage/meta_mem/ob_tablet_pointer.h b/src/storage/meta_mem/ob_tablet_pointer.h
index aee7435771..2c93e3cb05 100644
--- a/src/storage/meta_mem/ob_tablet_pointer.h
+++ b/src/storage/meta_mem/ob_tablet_pointer.h
@@ -15,10 +15,11 @@
 
 #include "lib/lock/ob_mutex.h"
 #include "storage/meta_mem/ob_meta_obj_struct.h"
-#include "storage/ob_i_memtable_mgr.h"
 #include "storage/tablet/ob_tablet_ddl_info.h"
 #include "storage/tx_storage/ob_ls_handle.h"
 #include "storage/multi_data_source/mds_table_handler.h"
+#include "storage/ob_i_memtable_mgr.h"
+#include "storage/ob_protected_memtable_mgr_handle.h"
 
 namespace oceanbase
 {
@@ -35,8 +36,7 @@ class ObTabletPointer final
   friend class ObTenantMetaMemMgr;
 public:
   ObTabletPointer();
-  ObTabletPointer(
-      const ObLSHandle &ls_handle,
+  ObTabletPointer(const ObLSHandle &ls_handle,
       const ObMemtableMgrHandle &memtable_mgr_handle);
   ~ObTabletPointer();
   int get_in_memory_obj(ObMetaObjGuard<ObTablet> &guard);
@@ -76,7 +76,7 @@ public:
 
   // do not KPC memtable_mgr, may dead lock
   TO_STRING_KV(K_(phy_addr), K_(obj), K_(ls_handle), K_(ddl_kv_mgr_handle),
-      KP(memtable_mgr_handle_.get_memtable_mgr()), K_(ddl_info), K_(initial_state), KP_(old_version_chain));
+      K_(protected_memtable_mgr_handle), K_(ddl_info), K_(initial_state), KP_(old_version_chain));
 public:
   bool get_initial_state() const;
   void set_initial_state(const bool initial_state);
@@ -84,14 +84,14 @@ public:
   void get_ddl_kv_mgr(ObDDLKvMgrHandle &ddl_kv_mgr_handle);
   int set_ddl_kv_mgr(const ObDDLKvMgrHandle &ddl_kv_mgr_handle);
   int remove_ddl_kv_mgr(const ObDDLKvMgrHandle &ddl_kv_mgr_handle);
-  int get_mds_table(mds::MdsTableHandle &handle, bool not_exist_create = false);
+  int get_mds_table(const ObTabletID &tablet_id, mds::MdsTableHandle &handle, bool not_exist_create = false);
   // interfaces forward to mds_table_handler_
   void mark_mds_table_deleted();
   void set_tablet_status_written();
   bool is_tablet_status_written() const;
   int try_release_mds_nodes_below(const share::SCN &scn);
   int try_gc_mds_table();
-  int release_memtable_and_mds_table_for_ls_offline();
+  int release_memtable_and_mds_table_for_ls_offline(const ObTabletID &tablet_id);
   int get_min_mds_ckpt_scn(share::SCN &scn);
   ObLS *get_ls() const;
 private:
@@ -103,7 +103,7 @@ private:
   ObMetaObj<ObTablet> obj_; // 40B
   ObLSHandle ls_handle_; // 24B
   ObDDLKvMgrHandle ddl_kv_mgr_handle_; // 48B
-  ObMemtableMgrHandle memtable_mgr_handle_; // 16B
+  ObProtectedMemtableMgrHandle protected_memtable_mgr_handle_; // 32B
   ObTabletDDLInfo ddl_info_; // 32B
   bool initial_state_; // 1B
   ObByteLock ddl_kv_mgr_lock_; // 1B
diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
index a5843d8900..2e038712ee 100644
--- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
+++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
@@ -136,7 +136,6 @@ ObTenantMetaMemMgr::ObTenantMetaMemMgr(const uint64_t tenant_id)
     large_tablet_buffer_pool_(tenant_id, get_default_large_tablet_pool_count(), "L_TabletPool", ObCtxIds::META_OBJ_CTX_ID, &wash_func_, false/*allow_over_max_free_num*/),
     ddl_kv_pool_(tenant_id, MAX_DDL_KV_IN_OBJ_POOL, "DDLKVObj", ObCtxIds::DEFAULT_CTX_ID),
     tablet_ddl_kv_mgr_pool_(tenant_id, get_default_tablet_pool_count(), "DDLKvMgrObj", ObCtxIds::DEFAULT_CTX_ID),
-    tablet_memtable_mgr_pool_(tenant_id, get_default_tablet_pool_count(), "MemTblMgrObj", ObCtxIds::DEFAULT_CTX_ID),
     tx_data_memtable_pool_(tenant_id, MAX_TX_DATA_MEMTABLE_CNT_IN_OBJ_POOL, "TxDataMemObj", ObCtxIds::DEFAULT_CTX_ID),
     tx_ctx_memtable_pool_(tenant_id, MAX_TX_CTX_MEMTABLE_CNT_IN_OBJ_POOL, "TxCtxMemObj", ObCtxIds::DEFAULT_CTX_ID),
     lock_memtable_pool_(tenant_id, MAX_LOCK_MEMTABLE_CNT_IN_OBJ_POOL, "LockMemObj", ObCtxIds::DEFAULT_CTX_ID),
@@ -1152,45 +1151,6 @@ void ObTenantMetaMemMgr::release_tablet_ddl_kv_mgr(ObTabletDDLKvMgr *ddl_kv_mgr)
   }
 }
 
-int ObTenantMetaMemMgr::acquire_tablet_memtable_mgr(ObMemtableMgrHandle &handle)
-{
-  int ret = OB_SUCCESS;
-  ObTabletMemtableMgr *memtable_mgr = nullptr;
-
-  handle.reset();
-  if (OB_UNLIKELY(!is_inited_)) {
-    ret = OB_NOT_INIT;
-    LOG_WARN("ObTenantMetaMemMgr hasn't been initialized", K(ret));
-  } else if (OB_FAIL(tablet_memtable_mgr_pool_.acquire(memtable_mgr))) {
-    LOG_WARN("fail to acquire memtable manager object", K(ret));
-  } else if (OB_ISNULL(memtable_mgr)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable manager is null", K(ret), KP(memtable_mgr));
-  } else {
-    handle.set_memtable_mgr(memtable_mgr, &tablet_memtable_mgr_pool_);
-    memtable_mgr = nullptr;
-  }
-
-  if (OB_FAIL(ret)) {
-    handle.reset();
-    if (OB_NOT_NULL(memtable_mgr)) {
-      release_tablet_memtable_mgr(memtable_mgr);
-    }
-  }
-  return ret;
-}
-
-void ObTenantMetaMemMgr::release_tablet_memtable_mgr(ObTabletMemtableMgr *memtable_mgr)
-{
-  if (OB_NOT_NULL(memtable_mgr)) {
-    if (0 != memtable_mgr->get_ref()) {
-      LOG_ERROR_RET(OB_ERR_UNEXPECTED, "ObTabletMemtableMgr reference count may be leak", KPC(memtable_mgr));
-    } else {
-      tablet_memtable_mgr_pool_.release(memtable_mgr);
-    }
-  }
-}
-
 void ObTenantMetaMemMgr::release_tx_ctx_memtable_(ObTxCtxMemtable *memtable)
 {
   if (OB_NOT_NULL(memtable)) {
@@ -1245,7 +1205,7 @@ int ObTenantMetaMemMgr::release_memtable_and_mds_table_for_ls_offline(const ObTa
     LOG_ERROR_RET(OB_ERR_UNEXPECTED, "ptr_handle is null", KPC(ptr_handle.get_resource_ptr()));
   } else {
     ObTabletPointer *tablet_pointer = static_cast<ObTabletPointer *>(ptr_handle.get_resource_ptr());
-    if (OB_FAIL(tablet_pointer->release_memtable_and_mds_table_for_ls_offline())) {
+    if (OB_FAIL(tablet_pointer->release_memtable_and_mds_table_for_ls_offline(key.tablet_id_))) {
       LOG_WARN("failed to release memtable and mds table", K(ret), K(key));
     }
   }
@@ -1569,8 +1529,6 @@ int ObTenantMetaMemMgr::create_tablet(
     if (OB_FAIL(ls->get_tablet_svr()->get_lock_memtable_mgr(memtable_mgr_hdl))) {
       LOG_WARN("fail to get lock memtable mgr", K(ret));
     }
-  } else if (OB_FAIL(acquire_tablet_memtable_mgr(memtable_mgr_hdl))) {
-    LOG_WARN("fail to acquire tablet memtable mgr", K(ret));
   }
   if (OB_SUCC(ret)) {
     ObTabletPointerHandle ptr_handle(tablet_map_);
@@ -1795,8 +1753,6 @@ int ObTenantMetaMemMgr::get_meta_mem_status(common::ObIArray<ObTenantMetaMemStat
     LOG_WARN("fail to get large tablet pool's info", K(ret), K(info));
   } else if (OB_FAIL(get_obj_pool_info(tablet_ddl_kv_mgr_pool_, "KV MGR POOL", info))) {
     LOG_WARN("fail to get kv mgr pool's info", K(ret), K(info));
-  } else if (OB_FAIL(get_obj_pool_info(tablet_memtable_mgr_pool_, "MEMTABLE MGR POOL", info))) {
-    LOG_WARN("fail to get memtable mgr pool's info", K(ret), K(info));
   } else if (OB_FAIL(get_obj_pool_info(tx_data_memtable_pool_, "TX DATA MEMTABLE POOL", info))) {
     LOG_WARN("fail to get tx data memtable pool's info", K(ret), K(info));
   } else if (OB_FAIL(get_obj_pool_info(tx_ctx_memtable_pool_, "TX CTX MEMTABLE POOL", info))) {
@@ -2047,13 +2003,12 @@ int ObTenantMetaMemMgr::check_all_meta_mem_released(bool &is_released, const cha
     const int64_t tablet_cnt = tablet_buffer_pool_.get_used_obj_cnt();
     const int64_t large_tablet_cnt = large_tablet_buffer_pool_.get_used_obj_cnt();
     const int64_t ddl_kv_mgr_cnt = tablet_ddl_kv_mgr_pool_.get_used_obj_cnt();
-    const int64_t tablet_memtable_mgr_cnt = tablet_memtable_mgr_pool_.get_used_obj_cnt();
     const int64_t tx_data_memtable_cnt_ = tx_data_memtable_pool_.get_used_obj_cnt();
     const int64_t tx_ctx_memtable_cnt_ = tx_ctx_memtable_pool_.get_used_obj_cnt();
     const int64_t lock_memtable_cnt_ = lock_memtable_pool_.get_used_obj_cnt();
     const int64_t full_tablet_cnt = full_tablet_creator_.get_used_obj_cnt();
     if (memtable_cnt != 0 || ddl_kv_cnt != 0 || tablet_cnt != 0 || 0 != large_tablet_cnt || ddl_kv_mgr_cnt != 0
-        || tablet_memtable_mgr_cnt != 0 || tx_data_memtable_cnt_ != 0 || tx_ctx_memtable_cnt_ != 0
+        || tx_data_memtable_cnt_ != 0 || tx_ctx_memtable_cnt_ != 0
         || lock_memtable_cnt_ != 0 || full_tablet_cnt != 0) {
       is_released = false;
     } else {
@@ -2063,7 +2018,7 @@ int ObTenantMetaMemMgr::check_all_meta_mem_released(bool &is_released, const cha
     const int64_t wait_gc_tables_cnt = free_tables_queue_.size();
     const int64_t tablet_cnt_in_map = tablet_map_.count();
     LOG_INFO("check all meta mem in t3m", K(module), K(is_released), K(memtable_cnt), K(ddl_kv_cnt),
-        K(tablet_cnt), K(large_tablet_cnt), K(ddl_kv_mgr_cnt), K(tablet_memtable_mgr_cnt), K(tx_data_memtable_cnt_),
+        K(tablet_cnt), K(large_tablet_cnt), K(ddl_kv_mgr_cnt), K(tx_data_memtable_cnt_),
         K(tx_ctx_memtable_cnt_), K(lock_memtable_cnt_), K(full_tablet_cnt),
         K(wait_gc_tablets_cnt), K(wait_gc_tables_cnt), K(tablet_cnt_in_map));
   }
diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
index b87ef064e7..4c3c500039 100644
--- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
+++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
@@ -432,7 +432,6 @@ private:
   int acquire_tablet(const ObTabletPoolType type, ObTabletHandle &tablet_handle);
   int acquire_tablet(ObITenantMetaObjPool *pool, ObTablet *&tablet);
   int acquire_tablet_ddl_kv_mgr(ObDDLKvMgrHandle &handle);
-  int acquire_tablet_memtable_mgr(ObMemtableMgrHandle &handle);
   int create_tablet(const ObTabletMapKey &key, ObLSHandle &ls_handle, ObTabletHandle &tablet_handle);
   int do_wash_candidate_tablet(
       const CandidateTabletInfo &info,
@@ -448,7 +447,6 @@ private:
   void release_tablet(ObTablet *tablet);
   void release_ddl_kv(ObDDLKV *ddl_kv);
   void release_tablet_ddl_kv_mgr(ObTabletDDLKvMgr *ddl_kv_mgr);
-  void release_tablet_memtable_mgr(ObTabletMemtableMgr *memtable_mgr);
   void release_tx_data_memtable_(ObTxDataMemtable *memtable);
   void release_tx_ctx_memtable_(ObTxCtxMemtable *memtable);
   void release_lock_memtable_(transaction::tablelock::ObLockMemtable *memtable);
@@ -494,7 +492,6 @@ private:
   ObTenantMetaObjPool<ObLargeTabletBuffer> large_tablet_buffer_pool_;
   ObTenantMetaObjPool<ObDDLKV> ddl_kv_pool_;
   ObTenantMetaObjPool<ObTabletDDLKvMgr> tablet_ddl_kv_mgr_pool_;
-  ObTenantMetaObjPool<ObTabletMemtableMgr> tablet_memtable_mgr_pool_;
   ObTenantMetaObjPool<ObTxDataMemtable> tx_data_memtable_pool_;
   ObTenantMetaObjPool<ObTxCtxMemtable> tx_ctx_memtable_pool_;
   ObTenantMetaObjPool<transaction::tablelock::ObLockMemtable> lock_memtable_pool_;
diff --git a/src/storage/ob_i_memtable_mgr.cpp b/src/storage/ob_i_memtable_mgr.cpp
index 8cf2c8520f..634f85fd25 100644
--- a/src/storage/ob_i_memtable_mgr.cpp
+++ b/src/storage/ob_i_memtable_mgr.cpp
@@ -17,6 +17,7 @@
 #include "storage/memtable/ob_multi_source_data.h"
 #include "storage/tablet/ob_tablet.h"
 #include "storage/meta_mem/ob_tenant_meta_mem_mgr.h"
+#include "storage/tx_storage/ob_ls_service.h"
 
 using namespace oceanbase::share;
 using namespace oceanbase::memtable;
@@ -205,6 +206,31 @@ int ObIMemtableMgr::release_memtables()
   return ret;
 }
 
+int ObIMemtableMgr::init(
+    const ObLSID &ls_id,
+    const ObTabletID &tablet_id,
+    lib::Worker::CompatMode compat_mode)
+{
+  int ret = OB_SUCCESS;
+  ObLS *ls = nullptr;
+  ObLSService *ls_service = nullptr;
+  ObLSHandle ls_handle;
+  ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
+  if (OB_ISNULL(ls_service = MTL(ObLSService*))) {
+    ret = OB_ERR_UNEXPECTED;
+    STORAGE_LOG(WARN, "failed to get ObLSService from MTL", KR(ret), KPC(ls_service));
+  } else if (OB_FAIL(ls_service->get_ls(ls_id, ls_handle, ObLSGetMod::TABLET_MOD))) {
+    STORAGE_LOG(WARN, "failed to get ls", KR(ret), K(ls_id));
+  } else if (OB_ISNULL(ls = ls_handle.get_ls())) {
+    ret = OB_ERR_UNEXPECTED;
+    STORAGE_LOG(WARN, "ls should not be NULL", KR(ret), KP(ls));
+  } else if (OB_FAIL(init(tablet_id, ls_id, 0, 0, compat_mode,
+          ls->get_log_handler(), ls->get_freezer(), t3m))) {
+    STORAGE_LOG(WARN, "failed to init memtable mgr", KR(ret), K(tablet_id), K(ls_id));
+  }
+  return ret;
+}
+
 int ObIMemtableMgr::init(
     const ObTabletID &tablet_id,
     const share::ObLSID &ls_id,
@@ -345,7 +371,7 @@ ObMemtableMgrHandle::ObMemtableMgrHandle()
 {
 }
 
-ObMemtableMgrHandle::ObMemtableMgrHandle(ObIMemtableMgr *memtable_mgr, ObITenantMetaObjPool *pool)
+ObMemtableMgrHandle::ObMemtableMgrHandle(ObIMemtableMgr *memtable_mgr, ObTabletMemtableMgrPool *pool)
   : memtable_mgr_(memtable_mgr),
     pool_(pool)
 {
@@ -373,7 +399,7 @@ void ObMemtableMgrHandle::reset()
       memtable_mgr_ = nullptr;
     } else {
       if (0 == memtable_mgr_->dec_ref()) {
-        pool_->free_obj(static_cast<void *>(memtable_mgr_));
+        pool_->release(static_cast<ObTabletMemtableMgr*>(memtable_mgr_));
       }
       memtable_mgr_ = nullptr;
       pool_ = nullptr;
@@ -399,7 +425,7 @@ ObMemtableMgrHandle &ObMemtableMgrHandle::operator= (const ObMemtableMgrHandle &
   return *this;
 }
 
-int ObMemtableMgrHandle::set_memtable_mgr(ObIMemtableMgr *memtable_mgr, ObITenantMetaObjPool *pool)
+int ObMemtableMgrHandle::set_memtable_mgr(ObIMemtableMgr *memtable_mgr, ObTabletMemtableMgrPool *pool)
 {
   int ret = OB_SUCCESS;
   reset();
diff --git a/src/storage/ob_i_memtable_mgr.h b/src/storage/ob_i_memtable_mgr.h
index eeece4813a..ae61216ee6 100644
--- a/src/storage/ob_i_memtable_mgr.h
+++ b/src/storage/ob_i_memtable_mgr.h
@@ -192,7 +192,6 @@ private:
 
 class ObIMemtableMgr
 {
-
 public:
   ObIMemtableMgr(const LockType lock_type, void *lock)
     : is_inited_(false),
@@ -209,6 +208,11 @@ public:
   }
   virtual ~ObIMemtableMgr() { reset_tables(); }
 
+  int init(
+      const share::ObLSID &ls_id,
+      const ObTabletID &tablet_id,
+      const lib::Worker::CompatMode compat_mode);
+
   int init(
       const ObTabletID &tablet_id,
       const share::ObLSID &ls_id,
@@ -289,6 +293,8 @@ public:
   }
   virtual int reset_storage_recorder() { return common::OB_SUCCESS; }
   virtual int set_frozen_for_all_memtables() { return common::OB_SUCCESS; }
+  virtual int set_is_tablet_freeze_for_active_memtable(ObTableHandleV2 &handle) { return OB_NOT_SUPPORTED; }
+  virtual int get_last_frozen_memtable(ObTableHandleV2 &handle) const { return OB_NOT_SUPPORTED; }
   DECLARE_VIRTUAL_TO_STRING;
 protected:
   static int64_t get_memtable_idx(const int64_t pos) { return pos & (MAX_MEMSTORE_CNT - 1); }
@@ -324,7 +330,7 @@ class ObMemtableMgrHandle final
 {
 public:
   ObMemtableMgrHandle();
-  ObMemtableMgrHandle(ObIMemtableMgr *memtable_mgr, ObITenantMetaObjPool *pool = nullptr);
+  ObMemtableMgrHandle(ObIMemtableMgr *memtable_mgr, ObTabletMemtableMgrPool *pool);
   ~ObMemtableMgrHandle();
 
   bool is_valid() const;
@@ -336,13 +342,13 @@ public:
   ObMemtableMgrHandle(const ObMemtableMgrHandle &other);
   ObMemtableMgrHandle &operator= (const ObMemtableMgrHandle &other);
 
-  int set_memtable_mgr(ObIMemtableMgr *memtable_mgr, ObITenantMetaObjPool *pool = nullptr);
+  int set_memtable_mgr(ObIMemtableMgr *memtable_mgr, ObTabletMemtableMgrPool *pool = nullptr);
 
   TO_STRING_KV(KPC_(memtable_mgr), KP_(pool));
 
 private:
   ObIMemtableMgr *memtable_mgr_;
-  ObITenantMetaObjPool *pool_;
+  ObTabletMemtableMgrPool *pool_;
 };
 
 }  // namespace storage
diff --git a/src/storage/ob_protected_memtable_mgr_handle.cpp b/src/storage/ob_protected_memtable_mgr_handle.cpp
new file mode 100644
index 0000000000..33ceeeca30
--- /dev/null
+++ b/src/storage/ob_protected_memtable_mgr_handle.cpp
@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "storage/meta_mem/ob_tenant_meta_mem_mgr.h"
+#include "storage/ob_protected_memtable_mgr_handle.h"
+
+using namespace oceanbase::share;
+using namespace oceanbase::memtable;
+
+namespace oceanbase
+{
+namespace storage
+{
+
+int ObProtectedMemtableMgrHandle::create_tablet_memtable_mgr_(const ObLSID &ls_id,
+    const ObTabletID &tablet_id,
+    lib::Worker::CompatMode compat_mode)
+{
+  int ret = OB_SUCCESS;
+  ObTabletMemtableMgr *mgr = NULL;
+  ObTabletMemtableMgrPool *pool = MTL(ObTabletMemtableMgrPool*);
+  if (memtable_mgr_handle_.is_valid()) {
+  } else if (OB_ISNULL(mgr = pool->acquire())) {
+    ret = OB_ALLOCATE_MEMORY_FAILED;
+    STORAGE_LOG(WARN, "failed to memtable manager alloc", KR(ret), K(ls_id), K(tablet_id));
+  } else if (OB_FAIL(mgr->ObIMemtableMgr::init(ls_id, tablet_id, compat_mode))) {
+    pool->release(mgr);
+    STORAGE_LOG(WARN, "failed to init memtable mgr", KR(ret), K(tablet_id), K(ls_id));
+  } else {
+    memtable_mgr_handle_.set_memtable_mgr(mgr, pool);
+  }
+  return ret;
+}
+
+bool ObProtectedMemtableMgrHandle::need_reset_()
+{
+  bool ret = false;
+  SpinRLockGuard guard(memtable_mgr_handle_lock_);
+  ret = need_reset_without_lock_();
+  return ret;
+}
+
+bool ObProtectedMemtableMgrHandle::need_reset_without_lock_()
+{
+  bool ret = false;
+  ObIMemtableMgr *mgr = NULL;
+  if (!memtable_mgr_handle_.is_valid()) {
+    STORAGE_LOG(INFO, "tablet_memtable_handle has been invalid", KR(ret));
+  } else if (FALSE_IT(mgr = memtable_mgr_handle_.get_memtable_mgr())) {
+  } else if (!mgr->has_memtable()) {
+    ret = true;
+  }
+  return ret;
+}
+// only for non-inner tablet
+int ObProtectedMemtableMgrHandle::try_reset_memtable_mgr_handle_()
+{
+  int ret = OB_SUCCESS;
+  SpinWLockGuard guard(memtable_mgr_handle_lock_);
+  if (need_reset_without_lock_()) {
+    STORAGE_LOG(INFO, "memtable_mgr has no memtable, release it", KR(ret), KPC(this));
+    memtable_mgr_handle_.reset();
+  }
+  return ret;
+}
+
+int ObProtectedMemtableMgrHandle::reset()
+{
+  int ret = OB_SUCCESS;
+  SpinWLockGuard guard(memtable_mgr_handle_lock_);
+  if (memtable_mgr_handle_.is_valid()) {
+    ObIMemtableMgr *mgr = memtable_mgr_handle_.get_memtable_mgr();
+    if (OB_FAIL(mgr->has_memtable() && mgr->release_memtables())) {
+      STORAGE_LOG(ERROR, "failed to release memtables", KR(ret), KPC(this));
+    }
+    memtable_mgr_handle_.reset();
+  }
+  return ret;
+}
+
+int ObProtectedMemtableMgrHandle::release_memtables_and_try_reset_memtable_mgr_handle(
+    const ObTabletID &tablet_id,
+    const SCN &scn)
+{
+  int ret = OB_SUCCESS;
+  if (scn.is_valid() && OB_FAIL(release_memtables(scn))) {
+    STORAGE_LOG(WARN, "failed to release_memtables", KR(ret), K(tablet_id), K(scn));
+  } else if (!scn.is_valid() && OB_FAIL(release_memtables())) {
+    STORAGE_LOG(WARN, "failed to release_memtables", KR(ret), K(tablet_id));
+  } else if (tablet_id.is_ls_inner_tablet()) {
+    // do nothing
+  } else if (!need_reset_()) {
+  } else if (OB_FAIL(try_reset_memtable_mgr_handle_())) {
+    STORAGE_LOG(WARN, "failed to try_reset_memtable_mgr_handle", KR(ret), K(tablet_id), K(scn), KPC(this));
+  }
+  return ret;
+}
+
+} // namespace storage
+} // namespace oceanbase
diff --git a/src/storage/ob_protected_memtable_mgr_handle.h b/src/storage/ob_protected_memtable_mgr_handle.h
new file mode 100644
index 0000000000..df42584e26
--- /dev/null
+++ b/src/storage/ob_protected_memtable_mgr_handle.h
@@ -0,0 +1,187 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_STORAGE_OB_PROTECTED_MEMTABLE_MGR_HANDLE
+#define OCEANBASE_STORAGE_OB_PROTECTED_MEMTABLE_MGR_HANDLE
+
+#include "lib/lock/ob_spin_rwlock.h"
+#include "ob_tablet_id.h"
+#include "storage/ob_i_memtable_mgr.h"
+#include "storage/tablet/ob_tablet_meta.h"
+#include "storage/tablet/ob_tablet_memtable_mgr.h"
+
+#define PROCESS_FOR_MEMTABLE_MGR(...) \
+  do { \
+    { \
+      SpinRLockGuard guard(memtable_mgr_handle_lock_); \
+      if (memtable_mgr_handle_.is_valid()) { \
+        __VA_ARGS__ \
+        break; \
+      } \
+    } \
+    SpinWLockGuard guard(memtable_mgr_handle_lock_); \
+    if (!memtable_mgr_handle_.is_valid()) { \
+      STORAGE_LOG(INFO, "memtable_mgr_handle_ is not exist, need create", K(tablet_meta.ls_id_), K(tablet_meta.tablet_id_)); \
+      if (OB_FAIL(create_tablet_memtable_mgr_(tablet_meta.ls_id_, tablet_meta.tablet_id_, tablet_meta.compat_mode_))) { \
+        STORAGE_LOG(WARN, "failed to create_tablet_memtable_mgr", K(tablet_meta.ls_id_), K(tablet_meta.tablet_id_), K(tablet_meta.compat_mode_)); \
+      } \
+    } \
+  } while (OB_SUCC(ret));
+
+#define DELEGATE_FOR_MEMTABLE_MGR_WITH_CREATE(function) \
+template <typename ...Args> \
+int function(const ObTabletMeta &tablet_meta, \
+    Args &&...args) \
+{ \
+  int ret = OB_SUCCESS; \
+  PROCESS_FOR_MEMTABLE_MGR( \
+  { \
+    ret = memtable_mgr_handle_.get_memtable_mgr()->function(std::forward<Args>(args)...); \
+  }) \
+  return ret; \
+}
+
+#define DELEGATE_FOR_MEMTABLE_MGR(function, ignore_not_exist_error) \
+template <typename ...Args> \
+int function(Args &&...args) \
+{ \
+  int ret = OB_SUCCESS; \
+  SpinRLockGuard guard(memtable_mgr_handle_lock_); \
+  if (memtable_mgr_handle_.is_valid()) { \
+    ret = memtable_mgr_handle_.get_memtable_mgr()->function(std::forward<Args>(args)...); \
+  } else if (ignore_not_exist_error) { \
+    ret = OB_SUCCESS; \
+  } else { \
+    ret = OB_ENTRY_NOT_EXIST; \
+    STORAGE_LOG(INFO, "ObMemtableMgr is not exist, there is no memtable", KR(ret)); \
+  } \
+  return ret; \
+}
+
+#define READ_FOR_STORAGE_SCHEMA(recorder, value) \
+int64_t get_##value##_from_##recorder() \
+{ \
+  bool ret = 0; \
+  SpinRLockGuard guard(memtable_mgr_handle_lock_); \
+  if (memtable_mgr_handle_.is_valid()) { \
+    ObTabletMemtableMgr *tablet_memtable_mgr = static_cast<ObTabletMemtableMgr*>(memtable_mgr_handle_.get_memtable_mgr()); \
+    ret = tablet_memtable_mgr->get_##recorder().get_##value(); \
+  } \
+  return ret; \
+}
+
+#define WRITE_FOR_STORAGE_SCHEMA(recorder, process) \
+template <typename ...Args> \
+int process(const ObTabletMeta &tablet_meta, \
+    Args &&...args) \
+{ \
+  int ret = OB_SUCCESS; \
+  PROCESS_FOR_MEMTABLE_MGR( \
+  { \
+    ObTabletMemtableMgr *tablet_memtable_mgr = static_cast<ObTabletMemtableMgr*>(memtable_mgr_handle_.get_memtable_mgr()); \
+    ret = tablet_memtable_mgr->get_##recorder().process(std::forward<Args>(args)...); \
+  }) \
+  return ret; \
+}
+
+namespace oceanbase
+{
+namespace logservice
+{
+class ObLogHandler;
+}
+namespace memtable
+{
+class ObIMemtable;
+}
+
+namespace storage
+{
+
+class ObProtectedMemtableMgrHandle
+{
+public:
+  ObProtectedMemtableMgrHandle()
+    : memtable_mgr_handle_(),
+      memtable_mgr_handle_lock_() {}
+  ObProtectedMemtableMgrHandle(const ObMemtableMgrHandle &memtable_mgr_handle)
+    : memtable_mgr_handle_(memtable_mgr_handle),
+      memtable_mgr_handle_lock_() {}
+  ObProtectedMemtableMgrHandle& operator=(const ObProtectedMemtableMgrHandle &r)
+  {
+    SpinWLockGuard guard(memtable_mgr_handle_lock_);
+    memtable_mgr_handle_ = r.memtable_mgr_handle_;
+    return *this;
+  }
+  int reset();
+  TO_STRING_KV(K(memtable_mgr_handle_));
+
+  int release_memtables_and_try_reset_memtable_mgr_handle(const ObTabletID &tablet_id,
+      const share::SCN &scn);
+  bool has_active_memtable()
+  {
+    bool ret = false;
+    SpinRLockGuard guard(memtable_mgr_handle_lock_);
+    if (memtable_mgr_handle_.is_valid()) {
+      ret = static_cast<ObTabletMemtableMgr*>(memtable_mgr_handle_.get_memtable_mgr())->has_active_memtable();
+    }
+    return ret;
+  }
+
+  bool has_memtable()
+  {
+    bool ret = false;
+    SpinRLockGuard guard(memtable_mgr_handle_lock_);
+    if (memtable_mgr_handle_.is_valid()) {
+      ret = static_cast<ObTabletMemtableMgr*>(memtable_mgr_handle_.get_memtable_mgr())->has_memtable();
+    }
+    return ret;
+  }
+
+  READ_FOR_STORAGE_SCHEMA(medium_info_recorder, max_saved_version);
+  READ_FOR_STORAGE_SCHEMA(storage_schema_recorder, max_saved_version);
+  READ_FOR_STORAGE_SCHEMA(storage_schema_recorder, max_column_cnt);
+
+  WRITE_FOR_STORAGE_SCHEMA(medium_info_recorder, submit_medium_compaction_info);
+  WRITE_FOR_STORAGE_SCHEMA(medium_info_recorder, replay_medium_compaction_log);
+  WRITE_FOR_STORAGE_SCHEMA(storage_schema_recorder, try_update_storage_schema);
+  WRITE_FOR_STORAGE_SCHEMA(storage_schema_recorder, replay_schema_log);
+
+  DELEGATE_FOR_MEMTABLE_MGR(get_active_memtable, false);
+  DELEGATE_FOR_MEMTABLE_MGR(init, false);
+  DELEGATE_FOR_MEMTABLE_MGR(get_first_nonempty_memtable, false);
+  DELEGATE_FOR_MEMTABLE_MGR(set_frozen_for_all_memtables, true);
+  DELEGATE_FOR_MEMTABLE_MGR(get_all_memtables, true);
+  DELEGATE_FOR_MEMTABLE_MGR(get_boundary_memtable, false);
+  DELEGATE_FOR_MEMTABLE_MGR(set_is_tablet_freeze_for_active_memtable, false);
+  DELEGATE_FOR_MEMTABLE_MGR(get_last_frozen_memtable, false);
+  DELEGATE_FOR_MEMTABLE_MGR(get_memtable_for_replay, false);
+
+  DELEGATE_FOR_MEMTABLE_MGR_WITH_CREATE(get_newest_clog_checkpoint_scn);
+  DELEGATE_FOR_MEMTABLE_MGR_WITH_CREATE(create_memtable);
+
+private:
+  DELEGATE_FOR_MEMTABLE_MGR(release_memtables, true);
+  int try_reset_memtable_mgr_handle_();
+  bool need_reset_without_lock_();
+  bool need_reset_();
+  int create_tablet_memtable_mgr_(const share::ObLSID &ls_id,
+      const ObTabletID &tablet_id,
+      lib::Worker::CompatMode compat_mode);
+  ObMemtableMgrHandle memtable_mgr_handle_;
+  mutable common::SpinRWLock memtable_mgr_handle_lock_;
+};
+
+}  // namespace storage
+}  // namespace oceanbase
+
+#endif  // OCEANBASE_STORAGE_OB_PROTECTED_MEMTABLE_MGR_HANDLE
diff --git a/src/storage/ob_storage_table_guard.cpp b/src/storage/ob_storage_table_guard.cpp
index 19d18f59d7..2d0b052d27 100644
--- a/src/storage/ob_storage_table_guard.cpp
+++ b/src/storage/ob_storage_table_guard.cpp
@@ -196,7 +196,6 @@ int ObStorageTableGuard::refresh_and_protect_table(ObRelativeTable &relative_tab
 int ObStorageTableGuard::refresh_and_protect_memtable()
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = tablet_->get_memtable_mgr();
   memtable::ObIMemtable *memtable = nullptr;
   ObTableHandleV2 handle;
   const share::ObLSID &ls_id = tablet_->get_tablet_meta().ls_id_;
@@ -205,57 +204,56 @@ int ObStorageTableGuard::refresh_and_protect_memtable()
   bool bool_ret = true;
   bool for_replace_tablet_meta = false;
   const int64_t start = ObTimeUtility::current_time();
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
-  if (OB_ISNULL(memtable_mgr)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr is null", K(ret), KP(memtable_mgr));
-  } else {
-    do {
-      if (OB_FAIL(memtable_mgr->get_boundary_memtable(handle))) {
-        // if there is no memtable, create a new one
-        if (OB_ENTRY_NOT_EXIST == ret) {
-          LOG_DEBUG("there is no boundary memtable", K(ret), K(ls_id), K(tablet_id));
-          if (OB_FAIL(memtable_mgr->get_newest_clog_checkpoint_scn(clog_checkpoint_scn))) {
-            LOG_WARN("fail to get newest clog_checkpoint_scn", K(ret), K(ls_id), K(tablet_id));
-          } else if (replay_scn_ > clog_checkpoint_scn) {
-            // TODO: get the newest schema_version from tablet
-            ObLSHandle ls_handle;
-            if (OB_FAIL(MTL(ObLSService *)->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD))) {
-              LOG_WARN("failed to get log stream", K(ret), K(ls_id), K(tablet_id));
-            } else if (OB_UNLIKELY(!ls_handle.is_valid())) {
-              ret = OB_ERR_UNEXPECTED;
-              LOG_WARN("unexpected error, invalid ls handle", K(ret), K(ls_handle), K(ls_id), K(tablet_id));
-            } else if (OB_FAIL(ls_handle.get_ls()->get_tablet_svr()->create_memtable(
-                                                                                     tablet_id, 0/*schema version*/, for_replay_, clog_checkpoint_scn))) {
-              LOG_WARN("fail to create a boundary memtable", K(ret), K(ls_id), K(tablet_id));
-            }
-          } else { // replay_log_scn_ <= clog_checkpoint_scn
-            // no need to create a boundary memtable
-            ret = OB_SUCCESS;
-            break;
+  do {
+    if (OB_FAIL(tablet_->get_boundary_memtable(handle))) {
+      // if there is no memtable, create a new one
+      if (OB_ENTRY_NOT_EXIST == ret) {
+        LOG_DEBUG("there is no boundary memtable", K(ret), K(ls_id), K(tablet_id));
+        if (OB_FAIL(tablet_->get_protected_memtable_mgr_handle(protected_handle))) {
+          LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet_));
+        } else if (OB_FAIL(protected_handle->get_newest_clog_checkpoint_scn(
+                      tablet_->get_tablet_meta(), clog_checkpoint_scn))) {
+          LOG_WARN("fail to get newest clog_checkpoint_scn", K(ret), K(ls_id), K(tablet_id));
+        } else if (replay_scn_ > clog_checkpoint_scn) {
+          // TODO: get the newest schema_version from tablet
+          ObLSHandle ls_handle;
+          if (OB_FAIL(MTL(ObLSService *)->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD))) {
+            LOG_WARN("failed to get log stream", K(ret), K(ls_id), K(tablet_id));
+          } else if (OB_UNLIKELY(!ls_handle.is_valid())) {
+            ret = OB_ERR_UNEXPECTED;
+            LOG_WARN("unexpected error, invalid ls handle", K(ret), K(ls_handle), K(ls_id), K(tablet_id));
+          } else if (OB_FAIL(ls_handle.get_ls()->get_tablet_svr()->create_memtable(
+                                                                                   tablet_id, 0/*schema version*/, for_replay_, clog_checkpoint_scn))) {
+            LOG_WARN("fail to create a boundary memtable", K(ret), K(ls_id), K(tablet_id));
           }
-        } else { // OB_ENTRY_NOT_EXIST != ret
-          LOG_WARN("fail to get boundary memtable", K(ret), K(ls_id), K(tablet_id));
+        } else { // replay_log_scn_ <= clog_checkpoint_scn
+          // no need to create a boundary memtable
+          ret = OB_SUCCESS;
+          break;
         }
-      } else if (OB_FAIL(handle.get_memtable(memtable))) {
-        LOG_WARN("fail to get memtable from ObTableHandle", K(ret), K(ls_id), K(tablet_id));
-      } else if (OB_FAIL(check_freeze_to_inc_write_ref(memtable, bool_ret, for_replace_tablet_meta))) {
-        if (OB_EAGAIN == ret) {
-        } else if (OB_MINOR_FREEZE_NOT_ALLOW != ret) {
-          LOG_WARN("fail to check_freeze", K(ret), K(tablet_id), K(bool_ret), KPC(memtable));
-        }
-      } else {
-        // do nothing
+      } else { // OB_ENTRY_NOT_EXIST != ret
+        LOG_WARN("fail to get boundary memtable", K(ret), K(ls_id), K(tablet_id));
       }
-      const int64_t cost_time = ObTimeUtility::current_time() - start;
-      if (cost_time > 10 * 1000) {
-        if (TC_REACH_TIME_INTERVAL(10 * 1000)) {
-          TRANS_LOG_RET(WARN, OB_ERR_TOO_MUCH_TIME, "refresh replay table too much times", K(ret),
-                    K(ls_id), K(tablet_id), K(cost_time));
-        }
+    } else if (OB_FAIL(handle.get_memtable(memtable))) {
+      LOG_WARN("fail to get memtable from ObTableHandle", K(ret), K(ls_id), K(tablet_id));
+    } else if (OB_FAIL(check_freeze_to_inc_write_ref(memtable, bool_ret, for_replace_tablet_meta))) {
+      if (OB_EAGAIN == ret) {
+      } else if (OB_MINOR_FREEZE_NOT_ALLOW != ret) {
+        LOG_WARN("fail to check_freeze", K(ret), K(tablet_id), K(bool_ret), KPC(memtable));
       }
-    } while ((OB_SUCC(ret) || OB_ENTRY_NOT_EXIST == ret || OB_EAGAIN == ret) && bool_ret);
-  }
+    } else {
+      // do nothing
+    }
+    const int64_t cost_time = ObTimeUtility::current_time() - start;
+    if (cost_time > 10 * 1000) {
+      if (TC_REACH_TIME_INTERVAL(10 * 1000)) {
+        TRANS_LOG_RET(WARN, OB_ERR_TOO_MUCH_TIME, "refresh replay table too much times", K(ret),
+                  K(ls_id), K(tablet_id), K(cost_time));
+      }
+    }
+  } while ((OB_SUCC(ret) || OB_ENTRY_NOT_EXIST == ret || OB_EAGAIN == ret) && bool_ret);
 
   return ret;
 }
@@ -311,7 +309,6 @@ int ObStorageTableGuard::check_freeze_to_inc_write_ref(ObITable *table, bool &bo
   bool_ret = true;
   const share::ObLSID &ls_id = tablet_->get_tablet_meta().ls_id_;
   const common::ObTabletID &tablet_id = tablet_->get_tablet_meta().tablet_id_;
-  ObIMemtableMgr *memtable_mgr = tablet_->get_memtable_mgr();
   // need to make sure the memtable is a right boundary memtable
   memtable::ObIMemtable *memtable = static_cast<memtable::ObIMemtable *>(table);
   memtable::ObIMemtable *old_memtable = memtable;
@@ -319,11 +316,9 @@ int ObStorageTableGuard::check_freeze_to_inc_write_ref(ObITable *table, bool &bo
   // prevent that the memtable transforms from active to frozen before inc_write_ref
   uint32_t old_freeze_flag = 0;
   bool is_tablet_freeze = false;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
-  if (OB_ISNULL(memtable_mgr)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr is null", K(ret), K(bool_ret), K(ls_id), K(tablet_id), KP(memtable_mgr));
-  } else if (OB_ISNULL(table)) {
+  if (OB_ISNULL(table)) {
     LOG_INFO("table is null, need to refresh", K(bool_ret), K(ls_id), K(tablet_id));
   } else if (FALSE_IT(old_freeze_flag = memtable->get_freeze_flag())) {
   } else if (FALSE_IT(is_tablet_freeze = memtable->get_is_tablet_freeze())) {
@@ -333,7 +328,9 @@ int ObStorageTableGuard::check_freeze_to_inc_write_ref(ObITable *table, bool &bo
     if (for_replay_ || for_multi_source_data_) {
       // filter memtables for replay or multi_source_data according to scn
       ObTableHandleV2 handle;
-      if (OB_FAIL(memtable_mgr->get_memtable_for_replay(replay_scn_, handle))) {
+      if (OB_FAIL(tablet_->get_protected_memtable_mgr_handle(protected_handle))) {
+        LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet_));
+      } else if (OB_FAIL(protected_handle->get_memtable_for_replay(replay_scn_, handle))) {
         if (OB_NO_NEED_UPDATE == ret) {
           // no need to replay the log
           bool_ret = false;
@@ -357,16 +354,15 @@ int ObStorageTableGuard::check_freeze_to_inc_write_ref(ObITable *table, bool &bo
     // need to create a new memtable
     // TODO: allow to write frozen memtables except for the boundary one when replaying
     const int64_t write_ref = memtable->get_write_ref();
+    ObProtectedMemtableMgrHandle *protected_handle = NULL;
     if (0 == write_ref) {
       SCN clog_checkpoint_scn;
       bool need_create_memtable = true;
       SCN migration_clog_checkpoint_scn;
-      ObIMemtableMgr *memtable_mgr = tablet_->get_memtable_mgr();
-
-      if (OB_ISNULL(memtable_mgr)) {
-        ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("memtable mgr is null", K(ret), K(bool_ret), K(ls_id), K(tablet_id), KP(memtable_mgr));
-      } else if (OB_FAIL(memtable_mgr->get_newest_clog_checkpoint_scn(clog_checkpoint_scn))) {
+      if (OB_FAIL(tablet_->get_protected_memtable_mgr_handle(protected_handle))) {
+        LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(tablet_));
+      } else if (OB_FAIL(protected_handle->get_newest_clog_checkpoint_scn(
+                    tablet_->get_tablet_meta(), clog_checkpoint_scn))) {
         LOG_WARN("failed to get newest clog_checkpoint_scn", K(ret), K(ls_id), K(tablet_id), K(clog_checkpoint_scn));
       } else if (FALSE_IT(migration_clog_checkpoint_scn = static_cast<memtable::ObMemtable *>(memtable)->get_migration_clog_checkpoint_scn())) {
       } else if (for_replay_ && !migration_clog_checkpoint_scn.is_min()) {
diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp
index f924cd492f..8a8cfad2f6 100644
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@@ -225,7 +225,6 @@ ObTablet::ObTablet()
     tablet_addr_(),
     allocator_(nullptr),
     memtables_lock_(),
-    memtable_mgr_(nullptr),
     log_handler_(nullptr),
     next_tablet_(nullptr),
     hold_ref_cnt_(false),
@@ -236,7 +235,7 @@ ObTablet::ObTablet()
     table_store_cache_()
 {
 #if defined(__x86_64__) && !defined(ENABLE_OBJ_LEAK_CHECK)
-  static_assert(sizeof(ObTablet) + sizeof(ObRowkeyReadInfo) == 1696, "The size of ObTablet will affect the meta memory manager, and the necessity of adding new fields needs to be considered.");
+  static_assert(sizeof(ObTablet) + sizeof(ObRowkeyReadInfo) == 1688, "The size of ObTablet will affect the meta memory manager, and the necessity of adding new fields needs to be considered.");
 #endif
   MEMSET(memtables_, 0x0, sizeof(memtables_));
 }
@@ -260,7 +259,6 @@ void ObTablet::reset()
   table_store_cache_.reset();
   mds_data_.reset();
   tablet_addr_.reset();
-  memtable_mgr_ = nullptr;
   log_handler_ = nullptr;
   pointer_hdl_.reset();
   if (nullptr != rowkey_read_info_) {
@@ -319,10 +317,9 @@ int ObTablet::init_for_first_time_creation(
     LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
         K(create_scn), K(snapshot_version), K(storage_schema), K(compat_mode), KP(freezer));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (OB_FAIL(init_shared_params(ls_id, tablet_id, storage_schema.get_schema_version(),
       default_max_sync_medium_scn, compat_mode, freezer))) {
     LOG_WARN("failed to init shared params", K(ret), K(ls_id), K(tablet_id), K(compat_mode), KP(freezer));
@@ -407,10 +404,9 @@ int ObTablet::init_for_merge(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(param), K(old_tablet));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (param.need_check_transfer_seq_ && OB_FAIL(check_transfer_seq_equal(old_tablet, param.transfer_seq_))) {
     LOG_WARN("failed to check transfer seq eq", K(ret), K(old_tablet), K(param));
   } else if (OB_FAIL(old_tablet.get_max_sync_storage_schema_version(max_sync_schema_version))) {
@@ -525,10 +521,9 @@ int ObTablet::init_for_mds_table_dump(
     ret = OB_INIT_TWICE;
     LOG_WARN("init twice", K(ret), K(is_inited_));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (CLICK_FAIL(old_tablet.fetch_table_store(old_table_store_wrapper))) {
     LOG_WARN("failed to fetch old table store", K(ret), K(old_tablet));
   } else if (CLICK_FAIL(old_table_store_wrapper.get_member(old_table_store))) {
@@ -602,10 +597,9 @@ int ObTablet::init_with_migrate_param(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(param), KP(freezer));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (!is_update && OB_FAIL(init_shared_params(ls_id, tablet_id,
       param.max_sync_storage_schema_version_,
       param.max_serialized_medium_scn_,
@@ -702,10 +696,9 @@ int ObTablet::init_for_defragment(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("old tablet is invalid", K(ret), K(old_tablet));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (OB_FAIL(old_tablet.load_storage_schema(tmp_arena_allocator, old_storage_schema))) {
     LOG_WARN("failed to load storage schema", K(ret), K(old_tablet));
   } else if (OB_FAIL(old_tablet.fetch_table_store(old_table_store_wrapper))) {
@@ -815,10 +808,9 @@ int ObTablet::init_for_sstable_replace(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(param), K(old_tablet));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(log_handler));
   } else if (OB_FAIL(old_tablet.load_storage_schema(tmp_arena_allocator, old_storage_schema))) {
     LOG_WARN("failed to load storage schema", K(ret), K(old_tablet));
   } else if (OB_FAIL(old_tablet.fetch_table_store(old_table_store_wrapper))) {
@@ -1075,10 +1067,9 @@ int ObTablet::init_with_update_medium_info(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(old_tablet));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(pointer_hdl), K_(log_handler));
   } else if (OB_FAIL(assign_memtables(old_tablet.memtables_, old_tablet.memtable_count_))) {
     LOG_WARN("fail to assign memtables", K(ret));
   } else if (OB_ISNULL(ddl_kvs_ = static_cast<ObITable**>(allocator.alloc(sizeof(ObITable*) * DDL_KV_ARRAY_SIZE)))) {
@@ -1153,10 +1144,9 @@ int ObTablet::init_with_new_snapshot_version(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid args", K(ret), K(old_tablet), K(snapshot_version));
   } else if (OB_UNLIKELY(!pointer_hdl_.is_valid())
-      || OB_ISNULL(memtable_mgr_)
       || OB_ISNULL(log_handler_)) {
     ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(pointer_hdl), K_(memtable_mgr), K_(log_handler));
+    LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl), K_(pointer_hdl), K_(log_handler));
   } else if (OB_FAIL(assign_memtables(old_tablet.memtables_, old_tablet.memtable_count_))) {
     LOG_WARN("fail to assign memtables", K(ret));
   } else if (OB_FAIL(old_tablet.fetch_table_store(table_store_wrapper))) {
@@ -2902,17 +2892,17 @@ int ObTablet::deserialize_id(
 int ObTablet::get_max_sync_medium_scn(int64_t &max_medium_snapshot) const
 {
   int ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
   max_medium_snapshot = 0;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
   } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
   } else {
-    max_medium_snapshot = data_memtable_mgr->get_medium_info_recorder().get_max_saved_version();
+    max_medium_snapshot = protected_handle->get_max_saved_version_from_medium_info_recorder();
   }
   return ret;
 }
@@ -2921,13 +2911,13 @@ int ObTablet::get_max_sync_storage_schema_version(int64_t &max_schema_version) c
 {
   int ret = OB_SUCCESS;
   max_schema_version = 0;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
   if (is_ls_inner_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
   } else {
-    max_schema_version = data_memtable_mgr->get_storage_schema_recorder().get_max_saved_version();
+    max_schema_version = protected_handle->get_max_saved_version_from_storage_schema_recorder();
   }
   return ret;
 }
@@ -2939,18 +2929,18 @@ int ObTablet::try_update_storage_schema(
     const int64_t timeout_ts)
 {
   int ret = OB_SUCCESS;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
   } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().try_update_storage_schema(
-      table_id, schema_version, allocator, timeout_ts))) {
-    LOG_WARN("fail to record storage schema", K(ret), K(table_id), K(schema_version), K(timeout_ts));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->try_update_storage_schema(get_tablet_meta(),
+          table_id, schema_version, allocator, timeout_ts))) {
+    LOG_WARN("failed to try_update_storage_schema", K(ret), KPC(this));
   }
   return ret;
 }
@@ -2958,17 +2948,18 @@ int ObTablet::try_update_storage_schema(
 int ObTablet::get_max_column_cnt_on_schema_recorder(int64_t &max_column_cnt)
 {
   int ret = OB_SUCCESS;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  max_column_cnt = 0;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
   } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
   } else {
-    max_column_cnt = data_memtable_mgr->get_storage_schema_recorder().get_max_column_cnt();
+    max_column_cnt = protected_handle->get_max_column_cnt_from_storage_schema_recorder();
   }
   return ret;
 }
@@ -2991,13 +2982,9 @@ int ObTablet::get_max_schema_version(int64_t &schema_version)
 {
   int ret = OB_SUCCESS;
   schema_version = -1;
-  ObTableHandleArray table_handle_array;
-  ObIMemtableMgr *memtable_mgr = nullptr;
-
-  if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->get_all_memtables(table_handle_array))) {
-    LOG_WARN("failed to get memtables", K(ret));
+  common::ObSEArray<ObTableHandleV2, 8> table_handle_array;
+  if (OB_FAIL(get_all_memtables(table_handle_array))) {
+    LOG_WARN("failed to get all memtable", K(ret), KPC(this));
   } else {
     const memtable::ObMemtable *memtable = nullptr;
     for (int64_t i = 0; OB_SUCC(ret) && i < table_handle_array.count(); ++i) {
@@ -4111,17 +4098,18 @@ int ObTablet::replay_update_storage_schema(
 {
   int ret = OB_SUCCESS;
   int64_t new_pos = pos;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
   } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(data_memtable_mgr->get_storage_schema_recorder().replay_schema_log(scn, buf, buf_size, new_pos))) {
-    LOG_WARN("storage schema recorder replay fail", K(ret), K(scn));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->replay_schema_log(get_tablet_meta(),
+          scn, buf, buf_size, new_pos))) {
+    LOG_WARN("failed to replay_schema_log", K(ret), K(scn), KPC(this));
   } else {
     pos = new_pos;
   }
@@ -4136,18 +4124,18 @@ int ObTablet::submit_medium_compaction_clog(
     ObIAllocator &allocator)
 {
   int ret = OB_SUCCESS;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
   } else if (tablet_meta_.tablet_id_.is_special_merge_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(data_memtable_mgr->get_medium_info_recorder().submit_medium_compaction_info(
-      medium_info, allocator))) {
-    LOG_WARN("medium compaction recorder submit fail", K(ret), K(medium_info));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->submit_medium_compaction_info(get_tablet_meta(),
+          medium_info, allocator))) {
+    LOG_WARN("failed to submit_medium_compaction_info", K(ret), K(medium_info), KPC(this));
   } else {
     LOG_DEBUG("success to submit medium compaction clog", K(medium_info));
   }
@@ -4162,7 +4150,7 @@ int ObTablet::replay_medium_compaction_clog(
 {
   int ret = OB_SUCCESS;
   int64_t new_pos = pos;
-  ObTabletMemtableMgr *data_memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     LOG_WARN("not inited", K(ret));
@@ -4171,10 +4159,11 @@ int ObTablet::replay_medium_compaction_clog(
     LOG_WARN("invalid argument", K(ret), K(buf_size), K(pos));
   } else if (tablet_meta_.tablet_id_.is_ls_inner_tablet()) {
     // do nothing
-  } else if (OB_FAIL(get_tablet_memtable_mgr(data_memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(data_memtable_mgr->get_medium_info_recorder().replay_medium_compaction_log(scn, buf, buf_size, new_pos))) {
-    LOG_WARN("medium compaction recorder replay fail", K(ret), KPC(this), K(buf_size), K(new_pos));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->replay_medium_compaction_log(get_tablet_meta(),
+          scn, buf, buf_size, new_pos))) {
+    LOG_WARN("failed to replay_medium_compaction_log", K(ret), K(scn), KPC(this));
   } else {
     pos = new_pos;
   }
@@ -4237,16 +4226,16 @@ int ObTablet::get_newest_schema_version(int64_t &schema_version) const
 int ObTablet::get_active_memtable(ObTableHandleV2 &handle) const
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret), K_(is_inited));
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->get_active_memtable(handle))) {
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->get_active_memtable(handle))) {
     if (OB_ENTRY_NOT_EXIST != ret) {
-      LOG_WARN("failed to get active memtable for tablet", K(ret), K(*this));
+      LOG_WARN("failed to get active memtable", K(ret), KPC(this));
     }
   }
   return ret;
@@ -4315,7 +4304,8 @@ int ObTablet::inner_create_memtable(
   int ret = OB_SUCCESS;
   const share::ObLSID &ls_id = tablet_meta_.ls_id_;
   const common::ObTabletID &tablet_id = tablet_meta_.tablet_id_;
-  ObIMemtableMgr *memtable_mgr = nullptr;
+  const SCN new_clog_checkpoint_scn = tablet_meta_.clog_checkpoint_scn_;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (OB_UNLIKELY(!clog_checkpoint_scn.is_valid_and_not_min()) || OB_UNLIKELY(schema_version < 0)) {
     ret = OB_INVALID_ARGUMENT;
@@ -4326,12 +4316,12 @@ int ObTablet::inner_create_memtable(
       LOG_WARN("The memtable array in the tablet reaches the upper limit, and no more memtable can "
           "be created", K(ret), K(memtable_count_), KPC(this));
     }
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->create_memtable(clog_checkpoint_scn, schema_version, tablet_meta_.clog_checkpoint_scn_, for_replay))) {
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->create_memtable(tablet_meta_, clog_checkpoint_scn, schema_version,
+          new_clog_checkpoint_scn, for_replay))) {
     if (OB_ENTRY_EXIST != ret && OB_MINOR_FREEZE_NOT_ALLOW != ret) {
-      LOG_WARN("failed to create memtable for tablet", K(ret), K(ls_id), K(tablet_id),
-          K(clog_checkpoint_scn), K(schema_version), K(for_replay));
+      LOG_WARN("failed to create memtable", K(ret), K(ls_id), K(tablet_id), KPC(this));
     }
   } else {
     LOG_INFO("succeeded to create memtable for tablet", K(ret), K(ls_id), K(tablet_id),
@@ -4387,40 +4377,44 @@ int ObTablet::rebuild_memtables(const share::SCN scn)
   return ret;
 }
 
+int ObTablet::inner_release_memtables(const SCN scn)
+{
+  int ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->release_memtables_and_try_reset_memtable_mgr_handle(tablet_meta_.tablet_id_, scn))) {
+    LOG_WARN("failed to release_memtables_and_try_reset_memtable_mgr_handle", K(ret), K(scn), KPC(this));
+  }
+  return ret;
+}
+
 int ObTablet::release_memtables(const SCN scn)
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret), K_(is_inited));
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->release_memtables(scn))) {
-    LOG_WARN("failed to release memtables", K(ret), K(scn));
+  } else if (OB_FAIL(inner_release_memtables(scn))) {
+    LOG_WARN("failed to release_memtables", K(ret), KPC(this));
   }
-
   return ret;
 }
 
 int ObTablet::release_memtables()
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret), K_(is_inited));
   } else if (is_empty_shell()) {
     LOG_DEBUG("tablet is empty shell", K(ret));
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->release_memtables())) {
-    LOG_WARN("failed to release memtables", K(ret));
+  } else if (OB_FAIL(inner_release_memtables(share::SCN()))) {
+    LOG_WARN("failed to release_memtables", K(ret), KPC(this));
   }
-
-  return ret;
+return ret;
 }
 
 int ObTablet::wait_release_memtables()
@@ -4440,23 +4434,18 @@ int ObTablet::wait_release_memtables()
 int ObTablet::wait_release_memtables_()
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
+  const int64_t start = ObTimeUtility::current_time();
 
-  if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else {
-    const int64_t start = ObTimeUtility::current_time();
-    do {
-      if (OB_FAIL(memtable_mgr->release_memtables())) {
-        const int64_t cost_time = ObTimeUtility::current_time() - start;
-        if (cost_time > 1000 * 1000) {
-          if (TC_REACH_TIME_INTERVAL(1000 * 1000)) {
-            LOG_WARN("failed to release memtables", K(ret), KPC(memtable_mgr));
-          }
+  do {
+    if (OB_FAIL(inner_release_memtables(share::SCN()))) {
+      const int64_t cost_time = ObTimeUtility::current_time() - start;
+      if (cost_time > 1000 * 1000) {
+        if (TC_REACH_TIME_INTERVAL(1000 * 1000)) {
+          LOG_WARN("failed to release memtables", K(ret), KPC(this));
         }
       }
-    } while (OB_FAIL(ret));
-  }
+    }
+  } while (OB_FAIL(ret));
 
   return ret;
 }
@@ -4479,37 +4468,6 @@ int ObTablet::mark_mds_table_switched_to_empty_shell_()
   return ret;
 }
 
-int ObTablet::get_memtable_mgr(ObIMemtableMgr *&memtable_mgr) const
-{
-  int ret = OB_SUCCESS;
-
-  ObTabletPointer *tablet_ptr = static_cast<ObTabletPointer*>(pointer_hdl_.get_resource_ptr());
-  ObMemtableMgrHandle &memtable_mgr_handle = tablet_ptr->memtable_mgr_handle_;
-  if (OB_UNLIKELY(!memtable_mgr_handle.is_valid())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr handle is invalid", K(ret), K(memtable_mgr_handle));
-  } else {
-    memtable_mgr = memtable_mgr_handle.get_memtable_mgr();
-  }
-
-  return ret;
-}
-
-int ObTablet::get_tablet_memtable_mgr(ObTabletMemtableMgr *&tablet_memtable_mgr) const
-{
-  int ret = OB_SUCCESS;
-  tablet_memtable_mgr = nullptr;
-  ObIMemtableMgr *memtable_mgr = nullptr;
-  if (tablet_meta_.tablet_id_.is_ls_inner_tablet()) {
-    // do nothing
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else {
-    tablet_memtable_mgr = static_cast<ObTabletMemtableMgr *>(memtable_mgr);
-  }
-  return ret;
-}
-
 int ObTablet::get_ddl_kv_mgr(ObDDLKvMgrHandle &ddl_kv_mgr_handle, bool try_create)
 {
   int ret = OB_SUCCESS;
@@ -4568,29 +4526,20 @@ int ObTablet::init_shared_params(
     ObFreezer *freezer)
 {
   int ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   if (OB_UNLIKELY(!pointer_hdl_.is_valid())) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("tablet pointer handle is invalid", K(ret), K_(pointer_hdl));
+  } else if (!tablet_id.is_ls_inner_tablet()) {
+    // tablet_memtable_mgr init in ObProtectedMemtableMgrHandle
   } else {
-    ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
-    ObIMemtableMgr *memtable_mgr = nullptr;
-
-    if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-      LOG_WARN("failed to get memtable mgr", K(ret));
-    } else if (OB_FAIL(memtable_mgr->init(
-            tablet_id,
-            ls_id,
-            max_saved_schema_version,
-            max_saved_medium_scn,
-            compat_mode,
-            log_handler_,
-            freezer,
-            t3m))) {
+    if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+      LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+    } else if (OB_FAIL(protected_handle->init(ls_id, tablet_id, compat_mode))) {
       LOG_WARN("failed to init memtable mgr", K(ret), K(tablet_id), K(ls_id), KP(freezer));
     }
   }
-
   return ret;
 }
 
@@ -5258,16 +5207,13 @@ int ObTablet::write_tablet_schema_version_change_clog(
 int ObTablet::replay_schema_version_change_log(const int64_t schema_version)
 {
   int ret = OB_SUCCESS;
-  ObTableHandleArray table_handle_array;
-  ObIMemtableMgr *memtable_mgr = nullptr;
+  common::ObSEArray<ObTableHandleV2, 8> table_handle_array;
 
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret));
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->get_all_memtables(table_handle_array))) {
-    LOG_WARN("failed to get memtables", K(ret));
+  } else if (OB_FAIL(get_all_memtables(table_handle_array))) {
+    LOG_WARN("failed to get all memtable", K(ret), KPC(this));
   } else {
     memtable::ObMemtable *memtable = nullptr;
     const int64_t table_num = table_handle_array.count();
@@ -5493,13 +5439,13 @@ int ObTablet::get_rec_log_scn(SCN &rec_scn) {
   rec_scn = SCN::max_scn();
   ObTableHandleV2 handle;
   memtable::ObMemtable *mt = NULL;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
   if (IS_NOT_INIT) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", KR(ret), K_(is_inited));
-  } else if (OB_ISNULL(memtable_mgr_)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable_mgr is NULL", KR(ret), KPC(this));
-  } else if (OB_FAIL(memtable_mgr_->get_first_nonempty_memtable(handle))) {
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->get_first_nonempty_memtable(handle))) {
     if (OB_ENTRY_NOT_EXIST == ret) {
       ret = OB_SUCCESS;
     } else {
@@ -5575,7 +5521,6 @@ int ObTablet::get_storage_schema_for_transfer_in(
   const share::ObLSID &ls_id = tablet_meta_.ls_id_;
   const common::ObTabletID &tablet_id = tablet_meta_.tablet_id_;
   ObStorageSchema *tablet_storage_schema = nullptr;
-  ObIMemtableMgr *memtable_mgr = nullptr;
   ObArray<ObTableHandleV2> memtables;
   int64_t max_column_cnt_in_memtable = 0;
   int64_t max_schema_version_in_memtable = 0;
@@ -5586,11 +5531,8 @@ int ObTablet::get_storage_schema_for_transfer_in(
   } else if (OB_UNLIKELY(tablet_id.is_ls_inner_tablet())) {
     ret = OB_NOT_SUPPORTED;
     LOG_WARN("not supported to get storage schema for ls inner tablet", KR(ret), K(tablet_id));
-  } else if (OB_ISNULL(memtable_mgr = get_memtable_mgr())) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable mgr should not be NULL", K(ret), KP(memtable_mgr));
-  } else if (OB_FAIL(memtable_mgr->get_all_memtables(memtables))) {
-    LOG_WARN("failed to get all memtables", K(ret), KPC(this));
+  } else if (OB_FAIL(get_all_memtables(memtables))) {
+    LOG_WARN("failed to get all memtable", K(ret), KPC(this));
   } else if (OB_FAIL(load_storage_schema(allocator, tablet_storage_schema))) {
     LOG_WARN("fail to load storage schema", K(ret), K_(storage_schema_addr));
   } else if (OB_FAIL(tablet_storage_schema->get_store_column_count(store_column_cnt_in_schema, true/*full_col*/))) {
@@ -5709,7 +5651,6 @@ int ObTablet::set_memtable_clog_checkpoint_scn(
     const ObMigrationTabletParam *tablet_meta)
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
   ObTableHandleV2 handle;
   memtable::ObMemtable *memtable = nullptr;
 
@@ -5720,14 +5661,12 @@ int ObTablet::set_memtable_clog_checkpoint_scn(
     // no need to set memtable clog checkpoint ts
   } else if (tablet_meta->clog_checkpoint_scn_ <= tablet_meta_.clog_checkpoint_scn_) {
     // do nothing
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
   } else if (is_ls_inner_tablet()) {
-    if (OB_UNLIKELY(memtable_mgr->has_memtable())) {
+    if (OB_UNLIKELY(has_memtable())) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("ls inner tablet should not have memtable", K(ret), KPC(tablet_meta));
     }
-  } else if (OB_FAIL(memtable_mgr->get_boundary_memtable(handle))) {
+  } else if (OB_FAIL(get_boundary_memtable(handle))) {
     if (OB_ENTRY_NOT_EXIST == ret) {
       ret = OB_SUCCESS;
     } else {
@@ -5925,7 +5864,6 @@ int64_t ObTablet::to_string(char *buf, const int64_t buf_len) const
          K_(next_tablet_guard),
          K_(pointer_hdl),
          KP_(next_tablet),
-         KP_(memtable_mgr),
          KP_(log_handler),
          KPC_(rowkey_read_info),
          K_(mds_data),
@@ -5990,13 +5928,10 @@ int ObTablet::pull_memtables_without_ddl()
   int ret = OB_SUCCESS;
   ObTableHandleArray memtable_handles;
 
-  if (OB_ISNULL(memtable_mgr_)) {
-    ret = OB_ERR_UNEXPECTED;
-    LOG_WARN("memtable_mgr_ is null", K(ret));
-  } else if (!memtable_mgr_->has_memtable()) {
+  if (!has_memtable()) {
     LOG_TRACE("no memtable in memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr_->get_all_memtables(memtable_handles))) {
-    LOG_WARN("failed to get all memtables from memtable_mgr", K(ret));
+  } else if (OB_FAIL(get_all_memtables(memtable_handles))) {
+    LOG_WARN("failed to get all memtable", K(ret), KPC(this));
   } else {
     int64_t start_snapshot_version = get_snapshot_version();
     const SCN& clog_checkpoint_scn = tablet_meta_.clog_checkpoint_scn_;
@@ -6086,14 +6021,11 @@ int ObTablet::update_memtables()
 {
   int ret = OB_SUCCESS;
   ObTableHandleArray inc_memtables;
-  ObIMemtableMgr *memtable_mgr;
 
-  if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable_mgr", K(ret));
-  } else if (!memtable_mgr->has_memtable()) {
+  if (!has_memtable()) {
     LOG_INFO("no memtable in memtable mgr", K(ret), "ls_id", tablet_meta_.ls_id_, "tablet_id", tablet_meta_.tablet_id_);
-  } else if (OB_FAIL(memtable_mgr->get_all_memtables(inc_memtables))) {
-    LOG_WARN("failed to get all memtables from memtable_mgr", K(ret));
+  } else if (OB_FAIL(get_all_memtables(inc_memtables))) {
+    LOG_WARN("failed to get all memtable", K(ret), KPC(this));
   } else if (is_ls_inner_tablet() && OB_FAIL(rebuild_memtable(inc_memtables))) {
     LOG_ERROR("failed to rebuild table store memtables for ls inner tablet", K(ret), K(inc_memtables), KPC(this));
   } else if (!is_ls_inner_tablet() && memtable_count_ > 0 && OB_FAIL(rebuild_memtable(inc_memtables))) {
@@ -6114,7 +6046,7 @@ int ObTablet::inner_get_mds_table(mds::MdsTableHandle &mds_table, bool not_exist
   if (OB_ISNULL(tablet_ptr = static_cast<ObTabletPointer*>(pointer_hdl_.get_resource_ptr()))) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("tablet pointer is null", K(ret), KPC(this));
-  } else if (OB_FAIL(tablet_ptr->get_mds_table(mds_table, not_exist_create))) {
+  } else if (OB_FAIL(tablet_ptr->get_mds_table(tablet_meta_.tablet_id_, mds_table, not_exist_create))) {
     if (OB_ENTRY_NOT_EXIST != ret) {
       LOG_WARN("failed to get mds table", K(ret));
     }
@@ -7303,19 +7235,70 @@ int ObTablet::inner_check_valid(const bool ignore_ha_status) const
 int ObTablet::set_frozen_for_all_memtables()
 {
   int ret = OB_SUCCESS;
-  ObIMemtableMgr *memtable_mgr = nullptr;
 
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
   if (OB_UNLIKELY(!is_inited_)) {
     ret = OB_NOT_INIT;
     LOG_WARN("not inited", K(ret), K_(is_inited));
-  } else if (OB_FAIL(get_memtable_mgr(memtable_mgr))) {
-    LOG_WARN("failed to get memtable mgr", K(ret));
-  } else if (OB_FAIL(memtable_mgr->set_frozen_for_all_memtables())){
-    LOG_WARN("failed to set_frozen_for_all_memtables", K(ret));
+  } else if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->set_frozen_for_all_memtables())) {
+    LOG_WARN("failed to set_frozen_for_all_memtables", K(ret), KPC(this));
   }
 
   return ret;
 }
 
+bool ObTablet::has_memtable() const
+{
+  bool ret = false;
+  int tmp_ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  if (OB_TMP_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(tmp_ret), KPC(this));
+  } else {
+    ret = protected_handle->has_memtable();
+  }
+  return ret;
+}
+
+int ObTablet::get_all_memtables(ObTableHdlArray &handle) const
+{
+  int ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->get_all_memtables(handle))) {
+    LOG_WARN("failed to get all memtable", K(ret));
+  }
+  return ret;
+}
+
+int ObTablet::get_boundary_memtable(ObTableHandleV2 &handle) const
+{
+  int ret = OB_SUCCESS;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  if (OB_FAIL(get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), KPC(this));
+  } else if (OB_FAIL(protected_handle->get_boundary_memtable(handle))) {
+    LOG_WARN("failed to get boundary memtable", K(ret));
+  }
+  return ret;
+}
+
+int ObTablet::get_protected_memtable_mgr_handle(ObProtectedMemtableMgrHandle *&handle) const
+{
+  int ret = OB_SUCCESS;
+  handle = NULL;
+  ObTabletPointer *tablet_ptr = NULL;
+  if (OB_ISNULL(tablet_ptr = static_cast<ObTabletPointer*>(pointer_hdl_.get_resource_ptr()))) {
+    ret = OB_ERR_UNEXPECTED;
+    STORAGE_LOG(WARN, "tablet pointer is null", KR(ret), KPC(this));
+  } else {
+    handle = &tablet_ptr->protected_memtable_mgr_handle_;
+  }
+  return ret;
+}
+
 } // namespace storage
 } // namespace oceanbase
diff --git a/src/storage/tablet/ob_tablet.h b/src/storage/tablet/ob_tablet.h
index dfe02d78e2..a49c9d27b0 100644
--- a/src/storage/tablet/ob_tablet.h
+++ b/src/storage/tablet/ob_tablet.h
@@ -372,7 +372,10 @@ public:
   int update_upper_trans_version(ObLS &ls, bool &is_updated);
 
   // memtable operation
-  ObIMemtableMgr *get_memtable_mgr() const { return memtable_mgr_; } // TODO(bowen.gbw): get memtable mgr from tablet pointer handle
+  bool has_memtable() const;
+  int get_all_memtables(ObTableHdlArray &handle) const;
+  int get_boundary_memtable(ObTableHandleV2 &handle) const;
+  int get_protected_memtable_mgr_handle(ObProtectedMemtableMgrHandle *&handle) const;
 
   // get the active memtable for write or replay.
   int get_active_memtable(ObTableHandleV2 &handle) const;
@@ -617,6 +620,7 @@ private:
   static int inc_linked_block_ref_cnt(const ObMetaDiskAddr &head_addr, bool &inc_success);
   static void dec_linked_block_ref_cnt(const ObMetaDiskAddr &head_addr);
   int64_t get_try_cache_size() const;
+  int inner_release_memtables(const share::SCN scn);
 private:
   static bool ignore_ret(const int ret);
   int inner_check_valid(const bool ignore_ha_status = false) const;
@@ -625,6 +629,8 @@ private:
   int64_t get_self_serialize_size() const;
   int get_memtable_mgr(ObIMemtableMgr *&memtable_mgr) const;
   int get_tablet_memtable_mgr(ObTabletMemtableMgr *&memtable_mgr) const;
+
+  int64_t get_self_size() const;
   int check_schema_version(const int64_t schema_version);
   int check_snapshot_readable(const int64_t snapshot_version);
   int get_column_store_sstable_checksum(common::ObIArray<int64_t> &column_checksums, ObCOSSTableV2 &co_sstable);
@@ -844,7 +850,6 @@ private:
   memtable::ObIMemtable *memtables_[MAX_MEMSTORE_CNT];
   ObArenaAllocator *allocator_;
   mutable common::SpinRWLock memtables_lock_;                // size: 12B, alignment: 4B
-  ObIMemtableMgr *memtable_mgr_;
   logservice::ObLogHandler *log_handler_;
 
   //ATTENTION : Add a new variable need consider ObMigrationTabletParam
diff --git a/src/storage/tablet/ob_tablet_memtable_mgr.h b/src/storage/tablet/ob_tablet_memtable_mgr.h
index dd8eb3caf6..01c0d5c325 100644
--- a/src/storage/tablet/ob_tablet_memtable_mgr.h
+++ b/src/storage/tablet/ob_tablet_memtable_mgr.h
@@ -144,6 +144,39 @@ private:
   ObStorageSchemaRecorder schema_recorder_; // 120B
   compaction::ObTabletMediumCompactionInfoRecorder medium_info_recorder_; // 96B
 };
+
+class ObTabletMemtableMgrPool
+{
+public:
+  ObTabletMemtableMgrPool()
+    : allocator_(sizeof(ObTabletMemtableMgr), lib::ObMemAttr(MTL_ID(), "TltMemtablMgr")),
+      count_(0) {}
+  static int mtl_init(ObTabletMemtableMgrPool* &m) { return OB_SUCCESS; }
+  void destroy() {}
+  ObTabletMemtableMgr* acquire()
+  {
+    void *ptr = allocator_.alloc();
+    ObTabletMemtableMgr *ret = NULL;
+    if (OB_NOT_NULL(ptr)) {
+      ret = new(ptr)ObTabletMemtableMgr();
+      ATOMIC_INC(&count_);
+    }
+    return ret;
+  }
+  void release(ObTabletMemtableMgr *mgr)
+  {
+    OB_ASSERT(OB_NOT_NULL(mgr));
+    mgr->~ObTabletMemtableMgr();
+    allocator_.free(static_cast<void*>(mgr));
+    ATOMIC_DEC(&count_);
+  }
+
+  int64_t get_count() { return ATOMIC_LOAD(&count_); }
+private:
+  common::ObSliceAlloc allocator_;
+  int64_t count_;
+};
+
 }
 }
 
diff --git a/unittest/storage/CMakeLists.txt b/unittest/storage/CMakeLists.txt
index f065f981a4..6ae06a5ccc 100644
--- a/unittest/storage/CMakeLists.txt
+++ b/unittest/storage/CMakeLists.txt
@@ -91,6 +91,7 @@ storage_dml_unittest(test_partition_range_splite)
 storage_dml_unittest(test_major_rows_merger)
 storage_dml_unittest(test_tablet tablet/test_tablet.cpp)
 storage_unittest(test_medium_list_checker compaction/test_medium_list_checker.cpp)
+storage_unittest(test_protected_memtable_mgr_handle test_protected_memtable_mgr_handle.cpp)
 
 if(OB_BUILD_CLOSE_MODULES)
 storage_dml_unittest(test_compaction_policy)
diff --git a/unittest/storage/test_compaction_policy.cpp b/unittest/storage/test_compaction_policy.cpp
index 81c0e53436..78767a9edd 100644
--- a/unittest/storage/test_compaction_policy.cpp
+++ b/unittest/storage/test_compaction_policy.cpp
@@ -318,7 +318,8 @@ int TestCompactionPolicy::mock_memtable(
     ObTableHandleV2 &table_handle)
 {
   int ret = OB_SUCCESS;
-  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(tablet.memtable_mgr_);
+  SCN clog_checkpoint_scn;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
 
   ObITable::TableKey table_key;
   int64_t end_border = -1;
@@ -334,7 +335,18 @@ int TestCompactionPolicy::mock_memtable(
   ObLSService *ls_svr = nullptr;
 
   ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr *);
-  if (OB_FAIL(t3m->acquire_memtable(table_handle))) {
+
+  if (OB_FAIL(tablet.get_protected_memtable_mgr_handle(protected_handle))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret), K(tablet));
+  }
+  // if memtable_mgr not exist, create it
+  else if (OB_FAIL(protected_handle->create_tablet_memtable_mgr_(
+          tablet.get_tablet_meta().ls_id_, tablet.get_tablet_meta().tablet_id_, lib::Worker::CompatMode::MYSQL))) {
+    LOG_WARN("failed to get_protected_memtable_mgr_handle", K(ret));
+  }
+  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(protected_handle->memtable_mgr_handle_.get_memtable_mgr());
+  if (OB_FAIL(ret)) {
+  } else if (OB_FAIL(t3m->acquire_memtable(table_handle))) {
     LOG_WARN("failed to acquire memtable", K(ret));
   } else if (OB_ISNULL(memtable = static_cast<ObMemtable*>(table_handle.get_table()))) {
     ret = OB_ERR_UNEXPECTED;
@@ -698,7 +710,6 @@ TEST_F(TestCompactionPolicy, basic_create_tablet)
   ObTablet *tablet = tablet_handle.get_obj();
   ObTabletTableStore &table_store = *tablet->table_store_addr_.get_ptr();
   ASSERT_EQ(true, table_store.is_valid());
-  ASSERT_TRUE(nullptr != tablet->memtable_mgr_);
 }
 
 TEST_F(TestCompactionPolicy, basic_create_memtable)
@@ -709,7 +720,13 @@ TEST_F(TestCompactionPolicy, basic_create_memtable)
   ASSERT_EQ(OB_SUCCESS, ret);
   ASSERT_EQ(true, tablet_handle.is_valid());
 
-  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(tablet_handle.get_obj()->memtable_mgr_);
+  SCN clog_checkpoint_scn;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->get_protected_memtable_mgr_handle(protected_handle));
+  // if memtable_mgr not exist, create it
+  const ObTabletMeta &tablet_meta = tablet_handle.get_obj()->get_tablet_meta();
+  ASSERT_EQ(OB_SUCCESS, protected_handle->create_tablet_memtable_mgr_(tablet_meta.ls_id_, tablet_meta.tablet_id_, lib::Worker::CompatMode::MYSQL));
+  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(protected_handle->memtable_mgr_handle_.get_memtable_mgr());
   ASSERT_EQ(0, mt_mgr->get_memtable_count_());
   ObTableHandleV2 frozen_memtable;
   ret = TestCompactionPolicy::mock_memtable(1, 100, 100, *tablet_handle.get_obj(), frozen_memtable);
@@ -811,7 +828,9 @@ TEST_F(TestCompactionPolicy, basic_prepare_tablet)
   ASSERT_EQ(2, table_store.major_tables_.count());
   ASSERT_EQ(2, table_store.minor_tables_.count());
 
-  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(tablet_handle_.get_obj()->memtable_mgr_);
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  ASSERT_EQ(OB_SUCCESS, tablet_handle_.get_obj()->get_protected_memtable_mgr_handle(protected_handle));
+  ObTabletMemtableMgr *mt_mgr = static_cast<ObTabletMemtableMgr *>(protected_handle->memtable_mgr_handle_.get_memtable_mgr());
   ASSERT_EQ(2, mt_mgr->get_memtable_count_());
 }
 
@@ -1085,7 +1104,7 @@ TEST_F(TestCompactionPolicy, test_minor_dag_intersect)
 int main(int argc, char **argv)
 {
   system("rm -rf test_compaction_policy.log*");
-  OB_LOGGER.set_file_name("test_compaction_policy.log");
+  OB_LOGGER.set_file_name("test_compaction_policy.log", true);
   OB_LOGGER.set_log_level("INFO");
   CLOG_LOG(INFO, "begin unittest: test_compaction_policy");
   ::testing::InitGoogleTest(&argc, argv);
diff --git a/unittest/storage/test_protected_memtable_mgr_handle.cpp b/unittest/storage/test_protected_memtable_mgr_handle.cpp
new file mode 100644
index 0000000000..414cf7df00
--- /dev/null
+++ b/unittest/storage/test_protected_memtable_mgr_handle.cpp
@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "share/ob_errno.h"
+#include <gtest/gtest.h>
+#include "storage/test_tablet_helper.h"
+#include <lib/oblog/ob_log.h>
+#include "storage/tx_storage/ob_ls_service.h"
+#include "mtlenv/mock_tenant_module_env.h"
+#include "init_basic_struct.h"
+
+#define USING_LOG_PREFIX STORAGE
+
+#define UNITTEST
+
+namespace oceanbase
+{
+namespace storage
+{
+namespace checkpoint
+{
+class TestTabletMemtableMgr : public ::testing::Test
+{
+public:
+  TestTabletMemtableMgr() {}
+  virtual ~TestTabletMemtableMgr() = default;
+
+  static void SetUpTestCase()
+  {
+    EXPECT_EQ(OB_SUCCESS, MockTenantModuleEnv::get_instance().init());
+    ObServerCheckpointSlogHandler::get_instance().is_started_ = true;
+  }
+
+  static void TearDownTestCase()
+  {
+    MockTenantModuleEnv::get_instance().destroy();
+  }
+};
+
+TEST_F(TestTabletMemtableMgr, tablet_memtable_mgr) {
+  ObArenaAllocator allocator;
+  ObLSID ls_id(2000);
+  ObTabletID tablet_id(500000);
+  ObLSHandle ls_handle;
+  ObLSService *ls_svr = MTL(ObLSService*);
+  ObTabletMemtableMgrPool *pool = MTL(ObTabletMemtableMgrPool*);
+  ObCreateLSArg arg;
+  ObTabletHandle tablet_handle;
+  share::schema::ObTableSchema table_schema;
+  share::SCN scn1;
+  scn1.set_base();
+  share::SCN scn2 = share::SCN::scn_inc(scn1);
+  uint64_t table_id = 12345;
+  ObProtectedMemtableMgrHandle *protected_handle = NULL;
+  ObTableHandleV2 handle;
+
+  ASSERT_EQ(OB_SUCCESS, gen_create_ls_arg(1, ls_id, arg));
+  ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->create_ls(arg));
+  ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD));
+
+  ASSERT_EQ(OB_SUCCESS, build_test_schema(table_schema, table_id));
+  ASSERT_EQ(OB_SUCCESS, TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema, allocator));
+  ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet_svr()->get_tablet(tablet_id, tablet_handle));
+  ASSERT_EQ(true, tablet_handle.is_valid());
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->get_protected_memtable_mgr_handle(protected_handle));
+
+  // memtable_mgr not exist
+  ASSERT_EQ(OB_ENTRY_NOT_EXIST, protected_handle->get_active_memtable(handle));
+  ASSERT_EQ(0, pool->count_);
+
+  // create memtable
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->create_memtable(1, scn1));
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->create_memtable(2, scn2));
+
+  // memtable_mgr exist
+  ASSERT_EQ(OB_SUCCESS, protected_handle->get_active_memtable(handle));
+  ASSERT_EQ(1, pool->count_);
+
+  // release a memtable, memtable count is 1
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->release_memtables(scn1));
+
+  // memtable_mgr exist yet
+  ASSERT_EQ(OB_SUCCESS, protected_handle->get_active_memtable(handle));
+  ASSERT_EQ(1, pool->count_);
+
+  // release other memtable, memtable count is 0, so release tablet_mgr
+  ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->release_memtables());
+
+  // memtable_mgr not exist
+  ASSERT_EQ(OB_ENTRY_NOT_EXIST, protected_handle->get_active_memtable(handle));
+  ASSERT_EQ(0, pool->count_);
+
+  ASSERT_EQ(OB_SUCCESS, MTL(ObLSService*)->remove_ls(ls_id, false));
+}
+
+
+}
+} // end namespace storage
+} // end namespace oceanbase
+
+int main(int argc, char **argv)
+{
+  int ret = 0;
+  system("rm -f test_checkpoint_diagnose.log*");
+  OB_LOGGER.set_file_name("test_tablet_memtable_mgr.log", true);
+  OB_LOGGER.set_log_level("INFO");
+  signal(49, SIG_IGN);
+  testing::InitGoogleTest(&argc, argv);
+  ret = RUN_ALL_TESTS();
+  return ret;
+}
diff --git a/unittest/storage/test_tablet_pointer_map.cpp b/unittest/storage/test_tablet_pointer_map.cpp
index 10416973d3..b23d2f1395 100644
--- a/unittest/storage/test_tablet_pointer_map.cpp
+++ b/unittest/storage/test_tablet_pointer_map.cpp
@@ -84,7 +84,9 @@ void TestMetaPointerMap::SetUp()
   ObTenantMetaMemMgr *t3m = OB_NEW(ObTenantMetaMemMgr, ObModIds::TEST, TEST_TENANT_ID);
   ASSERT_EQ(OB_SUCCESS, t3m->init());
 
+  ObTabletMemtableMgrPool *pool = OB_NEW(ObTabletMemtableMgrPool, ObModIds::TEST);
   tenant_base_.set(t3m);
+  tenant_base_.set(pool);
   ObTenantEnv::set_tenant(&tenant_base_);
   ASSERT_EQ(OB_SUCCESS, tenant_base_.init());
 }
@@ -147,11 +149,11 @@ TEST_F(TestMetaPointerMap, test_meta_pointer_handle)
   int ret = tablet_svr->init(&fake_ls);
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
-  ObMemtableMgrHandle memtable_mgr_hdl;
   ObDDLKvMgrHandle ddl_kv_mgr_hdl;
 
-  ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_memtable_mgr(memtable_mgr_hdl);
-  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ObTabletMemtableMgr *ptr = MTL(ObTabletMemtableMgrPool*)->acquire();
+  OB_ASSERT(NULL != ptr);
+  ObMemtableMgrHandle memtable_mgr_hdl(ptr, MTL(ObTabletMemtableMgrPool*));
 
   ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_ddl_kv_mgr(ddl_kv_mgr_hdl);
   ASSERT_EQ(common::OB_SUCCESS, ret);
@@ -210,11 +212,11 @@ TEST_F(TestMetaPointerMap, test_meta_pointer_map)
   int ret = tablet_svr->init(&fake_ls);
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
-  ObMemtableMgrHandle memtable_mgr_hdl;
   ObDDLKvMgrHandle ddl_kv_mgr_hdl;
 
-  ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_memtable_mgr(memtable_mgr_hdl);
-  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ObTabletMemtableMgr *ptr = MTL(ObTabletMemtableMgrPool*)->acquire();
+  OB_ASSERT(NULL != ptr);
+  ObMemtableMgrHandle memtable_mgr_hdl(ptr, MTL(ObTabletMemtableMgrPool*));
 
   ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_ddl_kv_mgr(ddl_kv_mgr_hdl);
   ASSERT_EQ(common::OB_SUCCESS, ret);
@@ -293,11 +295,11 @@ TEST_F(TestMetaPointerMap, test_erase_and_load_concurrency)
   int ret = tablet_svr->init(&fake_ls);
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
-  ObMemtableMgrHandle memtable_mgr_hdl;
   ObDDLKvMgrHandle ddl_kv_mgr_hdl;
 
-  ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_memtable_mgr(memtable_mgr_hdl);
-  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ObTabletMemtableMgr *ptr = MTL(ObTabletMemtableMgrPool*)->acquire();
+  OB_ASSERT(NULL != ptr);
+  ObMemtableMgrHandle memtable_mgr_hdl(ptr, MTL(ObTabletMemtableMgrPool*));
 
   ret = MTL(ObTenantMetaMemMgr*)->acquire_tablet_ddl_kv_mgr(ddl_kv_mgr_hdl);
   ASSERT_EQ(common::OB_SUCCESS, ret);