diff --git a/docs/cn/mbvar_c++.md b/docs/cn/mbvar_c++.md
index 8a81e71473..1ce1364f24 100644
--- a/docs/cn/mbvar_c++.md
+++ b/docs/cn/mbvar_c++.md
@@ -412,6 +412,7 @@ public:
 ```
 
 ### get_stats
+
 根据指定label获取对应的单维度统计项bvar。
 
 get_stats除了支持（默认）std::list<std::string>参数类型，也支持自定义参数类型，满足以下条件：
@@ -421,6 +422,12 @@ get_stats除了支持（默认）std::list<std::string>参数类型，也支持
 
 推荐使用不需要分配内存的容器（例如，std::array、absl::InlinedVector）和不需要拷贝字符串的数据结构（例如，const char*、std::string_view、butil::StringPieces），可以提高性能。
 
+bvar::MultiDimension的模板参数Shared，默认为false：
+1. 如果Shared等于false，get_stats返回模板参数T的指针，例如bvar::Adder<int>*。
+2. 如果Shared等于true，get_stats返回模板参数T的shared_ptr，例如std::shared_ptr\<bvar::Adder<int>\>。
+
+**注意**：因为shared_ptr的开销，Shared等于true的性能会比Shared等于false的性能差一些。
+
 ```c++
 #include <bvar/bvar.h>
 #include <bvar/multi_dimension.h>
@@ -523,6 +530,20 @@ int request_count = get_request_count(request_label_list);
     * store(bvar)
     * return bvar
 
+### delete_stats
+
+根据指定label删除对应的单维度统计项bvar。
+
+bvar::MultiDimension的模板参数Shared，默认为false：
+1. 如果Shared等于false，get_stats返回的是模板参数T的指针，delete_stats无法保证没有使用者，所以无法安全删除bvar。
+2. 如果Shared等于true，get_stats返回的是模板参数T的shared_ptr，delete_stats可以安全删除bvar。
+
+### clear_stats
+
+清理所有单维度统计项bvar。
+
+安全性同样受bvar::MultiDimension的模板参数Shared的影响，见delete_stats一节说明。
+
 **bvar的生命周期**
 
 label对应的单维度统计项bvar存储在多维度统计项(mbvar)中，当mbvar析构的时候会释放自身所有bvar，所以用户必须保证在mbvar的生命周期之内操作bvar，在mbvar生命周期外访问bvar的行为未定义，极有可能出core。
diff --git a/src/bvar/detail/combiner.h b/src/bvar/detail/combiner.h
index 3b4421809c..cae1b8ea8f 100644
--- a/src/bvar/detail/combiner.h
+++ b/src/bvar/detail/combiner.h
@@ -205,12 +205,10 @@ friend class GlobalValue<self_type>;
         // 
         // NOTE: Only available to non-atomic types.
         template <typename Op>
-        void merge_global(const Op &op, self_shared_type c = NULL) {
-            if (NULL == c) {
-                c = combiner.lock();
-            }
-            if (NULL != c) {
-                GlobalValue<self_type> g(this, c.get());
+        void merge_global(const Op &op, self_shared_type& c) {
+            const self_shared_type& c_ref = NULL != c ? c : combiner.lock();
+            if (NULL != c_ref) {
+                GlobalValue<self_type> g(this, c_ref.get());
                 element.merge_global(op, g);
             }
         }
diff --git a/src/bvar/multi_dimension.h b/src/bvar/multi_dimension.h
index 9163e3462e..ad352a02c9 100644
--- a/src/bvar/multi_dimension.h
+++ b/src/bvar/multi_dimension.h
@@ -20,6 +20,8 @@
 #ifndef BVAR_MULTI_DIMENSION_H
 #define BVAR_MULTI_DIMENSION_H
 
+#include <memory>
+#include <type_traits>
 #include "butil/logging.h"                           // LOG
 #include "butil/macros.h"                            // BAIDU_CASSERT
 #include "butil/scoped_lock.h"                       // BAIDU_SCOPE_LOCK
@@ -35,8 +37,15 @@ namespace bvar {
 // 2. KeyType::value_type must be std::string.
 // 3. KeyType::size() returns the number of labels.
 // 4. KeyType::push_back() adds a label to the end of the container.
-template <typename T, typename KeyType = std::list<std::string>>
+//
+// If `Shared' is false, `get_stats' returns a raw pointer,
+// `delete_stats' and `clear_stats' are not thread safe.
+// If `Shared' is true, `get_stats` returns a shared_ptr,
+// `delete_stats' and `clear_stats' are thread safe.
+// Note: The shared mode may be less performant than the non-shared mode.
+template <typename T, typename KeyType = std::list<std::string>, bool Shared = false>
 class MultiDimension : public MVariable<KeyType> {
+    typedef std::shared_ptr<T> shared_value_type;
 public:
     enum STATS_OP {
         READ_ONLY,
@@ -45,7 +54,7 @@ class MultiDimension : public MVariable<KeyType> {
 
     typedef KeyType key_type;
     typedef T value_type;
-    typedef T* value_ptr_type;
+    typedef typename std::conditional<Shared, shared_value_type, T*>::type value_ptr_type;
     typedef MVariable<key_type> Base;
 
     struct KeyHash {
@@ -102,11 +111,15 @@ class MultiDimension : public MVariable<KeyType> {
     // 2. K::value_type must be able to convert to std::string and butil::StringPiece
     //    through operator std::string() function and operator butil::StringPiece() function.
     // 3. K::value_type must be able to compare with std::string.
+    //
+    // Returns a shared_ptr if `Shared' is true, otherwise returns a raw pointer.
     template <typename K = key_type>
-    T* get_stats(const K& labels_value) {
+    value_ptr_type get_stats(const K& labels_value) {
         return get_stats_impl(labels_value, READ_OR_INSERT);
     }
 
+    // `delete_stats' and `clear_stats' are thread safe
+    // if `Shared' is true, otherwise not.
     // Remove stat so those not count and dump
     template <typename K = key_type>
     void delete_stats(const K& labels_value);
@@ -133,7 +146,7 @@ class MultiDimension : public MVariable<KeyType> {
     // Return real bvar pointer if labels_name exist, NULL otherwise.
     // CAUTION!!! Just For Debug!!!
     template <typename K = key_type>
-    T* get_stats_read_only(const K& labels_value) {
+    value_ptr_type get_stats_read_only(const K& labels_value) {
         return get_stats_impl(labels_value);
     }
 
@@ -141,17 +154,18 @@ class MultiDimension : public MVariable<KeyType> {
     // Return real bvar pointer if labels_name exist, otherwise(not exist) create bvar pointer.
     // CAUTION!!! Just For Debug!!!
     template <typename K = key_type>
-    T* get_stats_read_or_insert(const K& labels_value, bool* do_write = NULL) {
+    value_ptr_type get_stats_read_or_insert(const K& labels_value, bool* do_write = NULL) {
         return get_stats_impl(labels_value, READ_OR_INSERT, do_write);
     }
 #endif
 
 private:
     template <typename K>
-    T* get_stats_impl(const K& labels_value);
+    value_ptr_type get_stats_impl(const K& labels_value);
 
     template <typename K>
-    T* get_stats_impl(const K& labels_value, STATS_OP stats_op, bool* do_write = NULL);
+    value_ptr_type get_stats_impl(
+        const K& labels_value, STATS_OP stats_op, bool* do_write = NULL);
 
     template <typename K>
     static typename std::enable_if<butil::is_same<K, key_type>::value>::type
@@ -162,11 +176,8 @@ class MultiDimension : public MVariable<KeyType> {
     template <typename K>
     static typename std::enable_if<!butil::is_same<K, key_type>::value>::type
     insert_metrics_map(MetricMap& bg, const K& labels_value, op_value_type metric) {
-        key_type labels_value_str;
-        for (auto& label : labels_value) {
-            // key_type::value_type must be able to convert to std::string.
-            labels_value_str.push_back(std::string(label));
-        }
+        // key_type::value_type must be able to convert to std::string.
+        key_type labels_value_str(labels_value.cbegin(), labels_value.cend());
         bg.insert(labels_value_str, metric);
     }
 
@@ -192,7 +203,27 @@ class MultiDimension : public MVariable<KeyType> {
     void delete_stats();
     
     static size_t init_flatmap(MetricMap& bg);
-    
+
+    // If Shared is true, return std::shared_ptr, otherwise return raw pointer.
+    template <bool S = Shared>
+    typename std::enable_if<S, value_ptr_type>::type  new_value() {
+        return std::make_shared<value_type>();
+    }
+    template <bool S = Shared>
+    typename std::enable_if<!S, value_ptr_type>::type  new_value() {
+        return new value_type();
+    }
+
+    // If Shared is true, reset std::shared_ptr, otherwise delete raw pointer.
+    template <bool S = Shared>
+    typename std::enable_if<S>::type delete_value(value_ptr_type& v) {
+        v.reset();
+    }
+    template <bool S = Shared>
+    typename std::enable_if<!S>::type delete_value(value_ptr_type& v) {
+        delete v;
+    }
+
     size_t _max_stats_count;
     MetricMapDBD _metric_map;
 };
diff --git a/src/bvar/multi_dimension_inl.h b/src/bvar/multi_dimension_inl.h
index 15378248b5..c407567c54 100644
--- a/src/bvar/multi_dimension_inl.h
+++ b/src/bvar/multi_dimension_inl.h
@@ -21,6 +21,7 @@
 #define BVAR_MULTI_DIMENSION_INL_H
 
 #include <gflags/gflags_declare.h>
+#include "butil/compiler_specific.h"
 
 namespace bvar {
 
@@ -34,43 +35,43 @@ static const std::string ALLOW_UNUSED METRIC_TYPE_SUMMARY = "summary";
 static const std::string ALLOW_UNUSED METRIC_TYPE_HISTOGRAM = "histogram";
 static const std::string ALLOW_UNUSED METRIC_TYPE_GAUGE = "gauge";
 
-template <typename T, typename KeyType>
-MultiDimension<T, KeyType>::MultiDimension(const key_type& labels)
+template <typename T, typename KeyType, bool Shared>
+MultiDimension<T, KeyType, Shared>::MultiDimension(const key_type& labels)
     : Base(labels)
     , _max_stats_count(FLAGS_max_multi_dimension_stats_count) {
     _metric_map.Modify(init_flatmap);
 }
 
-template <typename T, typename KeyType>
-MultiDimension<T, KeyType>::MultiDimension(const butil::StringPiece& name,
+template <typename T, typename KeyType, bool Shared>
+MultiDimension<T, KeyType, Shared>::MultiDimension(const butil::StringPiece& name,
                                            const key_type& labels)
     : MultiDimension(labels) {
     this->expose(name);
 }
 
-template <typename T, typename KeyType>
-MultiDimension<T, KeyType>::MultiDimension(const butil::StringPiece& prefix,
+template <typename T, typename KeyType, bool Shared>
+MultiDimension<T, KeyType, Shared>::MultiDimension(const butil::StringPiece& prefix,
                                            const butil::StringPiece& name,
                                            const key_type& labels)
     : MultiDimension(labels) {
     this->expose_as(prefix, name);
 }
 
-template <typename T, typename KeyType>
-MultiDimension<T, KeyType>::~MultiDimension() {
+template <typename T, typename KeyType, bool Shared>
+MultiDimension<T, KeyType, Shared>::~MultiDimension() {
     this->hide();
     delete_stats();
 }
 
-template <typename T, typename KeyType>
-size_t MultiDimension<T, KeyType>::init_flatmap(MetricMap& bg) {
+template <typename T, typename KeyType, bool Shared>
+size_t MultiDimension<T, KeyType, Shared>::init_flatmap(MetricMap& bg) {
     // size = 1 << 13
     CHECK_EQ(0, bg.init(8192, 80));
-    return (size_t)1;
+    return 1;
 }
 
-template <typename T, typename KeyType>
-size_t MultiDimension<T, KeyType>::count_stats() {
+template <typename T, typename KeyType, bool Shared>
+size_t MultiDimension<T, KeyType, Shared>::count_stats() {
     MetricMapScopedPtr metric_map_ptr;
     if (_metric_map.Read(&metric_map_ptr) != 0) {
         LOG(ERROR) << "Fail to read dbd";
@@ -79,9 +80,9 @@ size_t MultiDimension<T, KeyType>::count_stats() {
     return metric_map_ptr->size();
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename K>
-void MultiDimension<T, KeyType>::delete_stats(const K& labels_value) {
+void MultiDimension<T, KeyType, Shared>::delete_stats(const K& labels_value) {
     if (is_valid_lables_value(labels_value)) {
         // Because there are two copies(foreground and background) in DBD,
         // we need to use an empty tmp_metric, get the deleted value of
@@ -93,35 +94,35 @@ void MultiDimension<T, KeyType>::delete_stats(const K& labels_value) {
         };
         _metric_map.Modify(erase_fn);
         if (tmp_metric) {
-            delete tmp_metric;
+            delete_value(tmp_metric);
         }
     }
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::delete_stats() {
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::delete_stats() {
     // Because there are two copies(foreground and background) in DBD, we need to use an empty tmp_map,
     // swap two copies with empty, and get the value of second copy into tmp_map,
     // then traversal tmp_map and delete bvar object,
     // which can prevent the bvar object from being deleted twice.
     MetricMap tmp_map;
     CHECK_EQ(0, tmp_map.init(8192, 80));
-    auto clear_fn = [&tmp_map](MetricMap& map) {
+    auto clear_fn = [&tmp_map](MetricMap& map) -> size_t {
         if (!tmp_map.empty()) {
             tmp_map.clear();
         }
         tmp_map.swap(map);
-        return (size_t)1;
+        return 1;
     };
     int ret = _metric_map.Modify(clear_fn);
     CHECK_EQ(1, ret);
-    for (auto &kv : tmp_map) {
-        delete kv.second;
+    for (auto& kv : tmp_map) {
+        delete_value(kv.second);
     }
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::list_stats(std::vector<key_type>* names) {
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::list_stats(std::vector<key_type>* names) {
     if (names == NULL) {
         return;
     }
@@ -137,58 +138,60 @@ void MultiDimension<T, KeyType>::list_stats(std::vector<key_type>* names) {
     }
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename K>
-T* MultiDimension<T, KeyType>::get_stats_impl(const K& labels_value) {
+typename MultiDimension<T, KeyType, Shared>::value_ptr_type
+MultiDimension<T, KeyType, Shared>::get_stats_impl(const K& labels_value) {
     if (!is_valid_lables_value(labels_value)) {
-        return nullptr;
+        return NULL;
     }
     MetricMapScopedPtr metric_map_ptr;
     if (_metric_map.Read(&metric_map_ptr) != 0) {
         LOG(ERROR) << "Fail to read dbd";
-        return nullptr;
+        return NULL;
     }
 
     auto it = metric_map_ptr->seek(labels_value);
-    if (it == nullptr) {
-        return nullptr;
+    if (NULL == it) {
+        return NULL;
     }
     return (*it);
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename K>
-T* MultiDimension<T, KeyType>::get_stats_impl(
+typename MultiDimension<T, KeyType, Shared>::value_ptr_type
+MultiDimension<T, KeyType, Shared>::get_stats_impl(
     const K& labels_value, STATS_OP stats_op, bool* do_write) {
     if (!is_valid_lables_value(labels_value)) {
-        return nullptr;
+        return NULL;
     }
     {
         MetricMapScopedPtr metric_map_ptr;
         if (0 != _metric_map.Read(&metric_map_ptr)) {
             LOG(ERROR) << "Fail to read dbd";
-            return nullptr;
+            return NULL;
         }
 
         auto it = metric_map_ptr->seek(labels_value);
         if (NULL != it) {
             return (*it);
         } else if (READ_ONLY == stats_op) {
-            return nullptr;
+            return NULL;
         }
 
         if (metric_map_ptr->size() > _max_stats_count) {
             LOG(ERROR) << "Too many stats seen, overflow detected, max stats count="
                        << _max_stats_count;
-            return nullptr;
+            return NULL;
         }
     }
 
-    // Because DBD has two copies(foreground and background) MetricMap, both copies need to be modify,
+    // Because DBD has two copies(foreground and background) MetricMap, both copies need to be modified,
     // In order to avoid new duplicate bvar object, need use cache_metric to cache the new bvar object,
     // In this way, when modifying the second copy, can directly use the cache_metric bvar object.
     op_value_type cache_metric = NULL;
-    auto insert_fn = [&labels_value, &cache_metric, &do_write](MetricMap& bg) {
+    auto insert_fn = [this, &labels_value, &cache_metric, &do_write](MetricMap& bg) {
         auto bg_metric = bg.seek(labels_value);
         if (NULL != bg_metric) {
             cache_metric = *bg_metric;
@@ -199,7 +202,7 @@ T* MultiDimension<T, KeyType>::get_stats_impl(
         }
 
         if (NULL == cache_metric) {
-            cache_metric = new T();
+            cache_metric = new_value();
         }
         insert_metrics_map(bg, labels_value, cache_metric);
         return 1;
@@ -208,21 +211,21 @@ T* MultiDimension<T, KeyType>::get_stats_impl(
     return cache_metric;
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::clear_stats() {
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::clear_stats() {
     delete_stats();
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename K>
-bool MultiDimension<T, KeyType>::has_stats(const K& labels_value) {
-    return get_stats_impl(labels_value) != nullptr;
+bool MultiDimension<T, KeyType, Shared>::has_stats(const K& labels_value) {
+    return get_stats_impl(labels_value) != NULL;
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename U>
 typename std::enable_if<!butil::is_same<LatencyRecorder, U>::value, size_t>::type
-MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions* options) {
+MultiDimension<T, KeyType, Shared>::dump_impl(Dumper* dumper, const DumpOptions* options) {
     std::vector<key_type> label_names;
     list_stats(&label_names);
     if (label_names.empty() || !dumper->dump_comment(this->name(), METRIC_TYPE_GAUGE)) {
@@ -230,8 +233,8 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions* options
     }
     size_t n = 0;
     for (auto &label_name : label_names) {
-        T* bvar = get_stats_impl(label_name);
-        if (!bvar) {
+        value_ptr_type bvar = get_stats_impl(label_name);
+        if (NULL == bvar) {
             continue;
         }
         std::ostringstream oss;
@@ -246,10 +249,10 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions* options
     return n;
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename U>
 typename std::enable_if<butil::is_same<LatencyRecorder, U>::value, size_t>::type
-MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions*) {
+MultiDimension<T, KeyType, Shared>::dump_impl(Dumper* dumper, const DumpOptions*) {
     std::vector<key_type> label_names;
     list_stats(&label_names);
     if (label_names.empty()) {
@@ -299,8 +302,8 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions*) {
     // max_latency comment
     dumper->dump_comment(this->name() + "_max_latency", METRIC_TYPE_GAUGE);
     for (auto &label_name : label_names) {
-        bvar::LatencyRecorder* bvar = get_stats_impl(label_name);
-        if (!bvar) {
+        LatencyRecorder* bvar = get_stats_impl(label_name);
+        if (NULL == bvar) {
             continue;
         }
         std::ostringstream oss_max_latency_key;
@@ -313,8 +316,8 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions*) {
     // qps comment
     dumper->dump_comment(this->name() + "_qps", METRIC_TYPE_GAUGE);
     for (auto &label_name : label_names) {
-        bvar::LatencyRecorder* bvar = get_stats_impl(label_name);
-        if (!bvar) {
+        LatencyRecorder* bvar = get_stats_impl(label_name);
+        if (NULL == bvar) {
             continue;
         }
         std::ostringstream oss_qps_key;
@@ -327,8 +330,8 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions*) {
     // count comment
     dumper->dump_comment(this->name() + "_count", METRIC_TYPE_COUNTER);
     for (auto &label_name : label_names) {
-        bvar::LatencyRecorder* bvar = get_stats_impl(label_name);
-        if (!bvar) {
+        LatencyRecorder* bvar = get_stats_impl(label_name);
+        if (NULL == bvar) {
             continue;
         }
         std::ostringstream oss_count_key;
@@ -340,8 +343,8 @@ MultiDimension<T, KeyType>::dump_impl(Dumper* dumper, const DumpOptions*) {
     return n;
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::make_dump_key(std::ostream& os, const key_type& labels_value,
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::make_dump_key(std::ostream& os, const key_type& labels_value,
                                                const std::string& suffix, int quantile) {
     os << this->name();
     if (!suffix.empty()) {
@@ -350,8 +353,8 @@ void MultiDimension<T, KeyType>::make_dump_key(std::ostream& os, const key_type&
     make_labels_kvpair_string(os, labels_value, quantile);
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::make_labels_kvpair_string(
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::make_labels_kvpair_string(
     std::ostream& os, const key_type& labels_value, int quantile) {
     os << "{";
     auto label_key = this->_labels.cbegin();
@@ -368,9 +371,9 @@ void MultiDimension<T, KeyType>::make_labels_kvpair_string(
     os << "}";
 }
 
-template <typename T, typename KeyType>
+template <typename T, typename KeyType, bool Shared>
 template <typename K>
-bool MultiDimension<T, KeyType>::is_valid_lables_value(const K& labels_value) const {
+bool MultiDimension<T, KeyType, Shared>::is_valid_lables_value(const K& labels_value) const {
     if (this->count_labels() != labels_value.size()) {
         LOG(ERROR) << "Invalid labels count" << this->count_labels()
                    << " != " << labels_value.size();
@@ -379,8 +382,8 @@ bool MultiDimension<T, KeyType>::is_valid_lables_value(const K& labels_value) co
     return true;
 }
 
-template <typename T, typename KeyType>
-void MultiDimension<T, KeyType>::describe(std::ostream& os) {
+template <typename T, typename KeyType, bool Shared>
+void MultiDimension<T, KeyType, Shared>::describe(std::ostream& os) {
     os << "{\"name\" : \"" << this->name() << "\", \"labels\" : [";
     char comma[3] = {'\0', ' ', '\0'};
     for (auto& label : this->_labels) {
diff --git a/test/bvar_multi_dimension_unittest.cpp b/test/bvar_multi_dimension_unittest.cpp
index 8d0e479d0d..a04ab4b78e 100644
--- a/test/bvar_multi_dimension_unittest.cpp
+++ b/test/bvar_multi_dimension_unittest.cpp
@@ -21,7 +21,7 @@
 #include <cstddef>
 #include <memory>
 #include <iostream>
-#include <set>
+#include <array>
 #include <string>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
@@ -497,3 +497,169 @@ TEST_F(MultiDimensionTest, test_hash) {
     LOG(INFO) << "Hash fun performance:\n" << oss.str();
 }
 
+
+class MyStringView {
+public:
+    MyStringView() : _ptr(NULL), _len(0) {}
+    MyStringView(const char* str)
+        : _ptr(str),
+          _len(str == NULL ? 0 : strlen(str)) {}
+#if __cplusplus >= 201703L
+    MyStringView(const std::string_view& str)
+        : _ptr(str.data()), _len(str.size()) {}
+#endif // __cplusplus >= 201703L
+    MyStringView(const std::string& str)
+        : _ptr(str.data()), _len(str.size()) {}
+    MyStringView(const char* offset, size_t len)
+        : _ptr(offset), _len(len) {}
+
+    const char* data() const { return _ptr; }
+    size_t size() const { return _len; }
+
+    // Converts to `std::basic_string`.
+    explicit operator std::string() const {
+        if (NULL == _ptr) {
+            return {};
+        }
+        return {_ptr, size()};
+    }
+
+    // Converts to butil::StringPiece.
+    explicit operator butil::StringPiece() const {
+        if (NULL == _ptr) {
+            return {};
+        }
+        return {_ptr, size()};
+    }
+
+private:
+    const char* _ptr;
+    size_t _len;
+};
+
+bool operator==(const MyStringView& x, const std::string& y) {
+    if (x.size() != y.size()) {
+        return false;
+    }
+
+    return butil::StringPiece::wordmemcmp(x.data(), y.data(), x.size()) == 0;
+}
+
+bool operator==(const std::string& x, const MyStringView& y) {
+    if (x.size() != y.size()) {
+        return false;
+    }
+
+    return butil::StringPiece::wordmemcmp(x.data(), y.data(), x.size()) == 0;
+}
+
+static int g_exposed_count = 0;
+
+template <typename KeyType, typename ValueType>
+static void TestLabels() {
+    std::string mbvar_name = butil::string_printf("my_madder_%d", g_exposed_count);
+    KeyType labels{"idc", "method", "status"};
+    bvar::MultiDimension<bvar::Adder<int>, KeyType> my_madder(mbvar_name, labels);
+    ASSERT_EQ(labels.size(), my_madder.count_labels());
+    ASSERT_STREQ(mbvar_name.c_str(), my_madder.name().c_str());
+    ASSERT_EQ(labels, my_madder.labels());
+
+    using ItemType = typename ValueType::value_type;
+    ValueType labels_value{ItemType("cv"), ItemType("post"), ItemType("200")};
+    bvar::Adder<int>* adder = my_madder.get_stats(labels_value);
+    ASSERT_NE(nullptr, adder);
+    ASSERT_TRUE(my_madder.has_stats(labels_value));
+    ASSERT_EQ((size_t)1, my_madder.count_stats());
+    {
+        // Compatible with old API.
+        bvar::Adder<int>* temp = my_madder.get_stats({"cv", "post", "200"});
+        ASSERT_EQ(adder, temp);
+    }
+    *adder << g_exposed_count;
+    ASSERT_EQ(g_exposed_count, adder->get_value());
+    my_madder.delete_stats(labels_value);
+    ASSERT_FALSE(my_madder.has_stats(labels_value));
+    ASSERT_EQ((size_t)0, my_madder.count_stats());
+}
+
+TEST_F(MultiDimensionTest, labels) {
+    TestLabels<std::list<std::string>, std::list<std::string>>();
+    TestLabels<std::list<std::string>, std::vector<std::string>>();
+    TestLabels<std::list<std::string>, std::array<std::string, 3>>();
+
+    TestLabels<std::vector<std::string>, std::list<std::string>>();
+    TestLabels<std::vector<std::string>, std::vector<std::string>>();
+    TestLabels<std::vector<std::string>, std::array<std::string, 3>>();
+
+#if __cplusplus >= 201703L
+    TestLabels<std::list<std::string>, std::list<std::string_view>>();
+    TestLabels<std::list<std::string>, std::vector<std::string_view>>();
+    TestLabels<std::list<std::string>, std::array<std::string_view, 3>>();
+#endif // __cplusplus >= 201703L
+
+    TestLabels<std::vector<std::string>, std::list<butil::StringPiece>>();
+    TestLabels<std::vector<std::string>, std::vector<butil::StringPiece>>();
+    TestLabels<std::vector<std::string>, std::array<butil::StringPiece, 3>>();
+
+    TestLabels<std::list<std::string>, std::list<MyStringView>>();
+    TestLabels<std::list<std::string>, std::vector<MyStringView>>();
+    TestLabels<std::list<std::string>, std::array<MyStringView, 3>>();
+
+    TestLabels<std::vector<std::string>, std::list<MyStringView>>();
+    TestLabels<std::vector<std::string>, std::vector<MyStringView>>();
+    TestLabels<std::vector<std::string>, std::array<MyStringView, 3>>();
+}
+
+std::array<const char*, 3> g_labels_value{"idc", "post", "200"};
+bool g_shared_stop = false;
+
+void* get_shared_adder_thread(void* arg) {
+    auto my_madder =
+        (bvar::MultiDimension<bvar::Adder<int>, std::vector<std::string>, true>*)arg;
+    while (!g_shared_stop) {
+        auto adder = my_madder->get_stats(g_labels_value);
+        EXPECT_NE(nullptr, adder);
+        *adder << 1;
+    }
+    return NULL;
+}
+
+void* delete_shared_adder_thread(void* arg) {
+    auto my_madder =
+        (bvar::MultiDimension<bvar::Adder<int>, std::vector<std::string>, true>*)arg;
+    while (!g_shared_stop) {
+        my_madder->delete_stats(g_labels_value);
+    }
+    return NULL;
+}
+
+TEST_F(MultiDimensionTest, shared) {
+    bvar::MultiDimension<bvar::Adder<int>, std::vector<std::string>, true> my_madder(
+        "my_adder", {"idc", "method", "status"});
+    std::shared_ptr<bvar::Adder<int>> adder = my_madder.get_stats(g_labels_value);
+    ASSERT_NE(nullptr, adder);
+    ASSERT_TRUE(my_madder.has_stats(g_labels_value));
+    ASSERT_EQ((size_t)1, my_madder.count_stats());
+
+    *adder << 1;
+    ASSERT_EQ(1, adder->get_value());
+    my_madder.delete_stats(g_labels_value);
+    *adder << 1;
+    ASSERT_EQ(2, adder->get_value());
+    ASSERT_FALSE(my_madder.has_stats(g_labels_value));
+
+    const int get_num = 8;
+    std::vector<pthread_t> get_threads(get_num);
+    for (int i = 0; i < get_num; ++i) {
+        ASSERT_EQ(0, pthread_create(&get_threads[i], NULL, get_shared_adder_thread, &my_madder));
+    }
+    pthread_t delete_thread;
+    ASSERT_EQ(0, pthread_create(&delete_thread, NULL, delete_shared_adder_thread, &my_madder));
+    usleep(100 * 1000); // 100ms
+    g_shared_stop = true;
+    for (int i = 0; i < get_num; ++i) {
+        ASSERT_EQ(0, pthread_join(get_threads[i], NULL));
+    }
+    ASSERT_EQ(0, pthread_join(delete_thread, NULL));
+}
+
diff --git a/test/bvar_mvariable_unittest.cpp b/test/bvar_mvariable_unittest.cpp
index d72a2e5d09..aca50d5f69 100644
--- a/test/bvar_mvariable_unittest.cpp
+++ b/test/bvar_mvariable_unittest.cpp
@@ -117,118 +117,6 @@ TEST_F(MVariableTest, expose) {
     ASSERT_EQ(2, exposed_vars.size());
 }
 
-class MyStringView {
-public:
-    MyStringView() : _ptr(NULL), _len(0) {}
-    MyStringView(const char* str)
-        : _ptr(str),
-          _len(str == NULL ? 0 : strlen(str)) {}
-#if __cplusplus >= 201703L
-    MyStringView(const std::string_view& str)
-        : _ptr(str.data()), _len(str.size()) {}
-#endif // __cplusplus >= 201703L
-    MyStringView(const std::string& str)
-        : _ptr(str.data()), _len(str.size()) {}
-    MyStringView(const char* offset, size_t len)
-        : _ptr(offset), _len(len) {}
-
-    const char* data() const { return _ptr; }
-    size_t size() const { return _len; }
-
-    // Converts to `std::basic_string`.
-    explicit operator std::string() const {
-        if (NULL == _ptr) {
-            return {};
-        }
-        return {_ptr, size()};
-    }
-
-    // Converts to butil::StringPiece.
-    explicit operator butil::StringPiece() const {
-        if (NULL == _ptr) {
-            return {};
-        }
-        return {_ptr, size()};
-    }
-
-private:
-    const char* _ptr;
-    size_t _len;
-};
-
-bool operator==(const MyStringView& x, const std::string& y) {
-    if (x.size() != y.size()) {
-        return false;
-    }
-
-    return butil::StringPiece::wordmemcmp(x.data(), y.data(), x.size()) == 0;
-}
-
-bool operator==(const std::string& x, const MyStringView& y) {
-    if (x.size() != y.size()) {
-        return false;
-    }
-
-    return butil::StringPiece::wordmemcmp(x.data(), y.data(), x.size()) == 0;
-}
-
-static int g_exposed_count = 0;
-
-template <typename KeyType, typename ValueType>
-static void TestLabels() {
-    std::string mbvar_name = butil::string_printf("my_madder_%d", g_exposed_count);
-    KeyType labels{"idc", "method", "status"};
-    bvar::MultiDimension<bvar::Adder<int>, KeyType> my_madder(mbvar_name, labels);
-    ASSERT_EQ(labels.size(), my_madder.count_labels());
-    ASSERT_STREQ(mbvar_name.c_str(), my_madder.name().c_str());
-    ASSERT_EQ(labels, my_madder.labels());
-
-    using ItemType = typename ValueType::value_type;
-    ValueType labels_value{ItemType("cv"), ItemType("post"), ItemType("200")};
-    bvar::Adder<int>* adder = my_madder.get_stats(labels_value);
-    ASSERT_NE(nullptr, adder);
-    ASSERT_TRUE(my_madder.has_stats(labels_value));
-    ASSERT_EQ((size_t)1, my_madder.count_stats());
-    {
-        // Compatible with old API.
-        bvar::Adder<int>* temp = my_madder.get_stats({"cv", "post", "200"});
-        ASSERT_EQ(adder, temp);
-    }
-    *adder << g_exposed_count;
-    ASSERT_EQ(g_exposed_count, adder->get_value());
-    my_madder.delete_stats(labels_value);
-    ASSERT_FALSE(my_madder.has_stats(labels_value));
-    ASSERT_EQ((size_t)0, my_madder.count_stats());
-}
-
-TEST_F(MVariableTest, labels) {
-    TestLabels<std::list<std::string>, std::list<std::string>>();
-    TestLabels<std::list<std::string>, std::vector<std::string>>();
-    TestLabels<std::list<std::string>, std::array<std::string, 3>>();
-
-    TestLabels<std::vector<std::string>, std::list<std::string>>();
-    TestLabels<std::vector<std::string>, std::vector<std::string>>();
-    TestLabels<std::vector<std::string>, std::array<std::string, 3>>();
-
-#if __cplusplus >= 201703L
-    TestLabels<std::list<std::string>, std::list<std::string_view>>();
-    TestLabels<std::list<std::string>, std::vector<std::string_view>>();
-    TestLabels<std::list<std::string>, std::array<std::string_view, 3>>();
-#endif // __cplusplus >= 201703L
-
-    TestLabels<std::vector<std::string>, std::list<butil::StringPiece>>();
-    TestLabels<std::vector<std::string>, std::vector<butil::StringPiece>>();
-    TestLabels<std::vector<std::string>, std::array<butil::StringPiece, 3>>();
-
-    TestLabels<std::list<std::string>, std::list<MyStringView>>();
-    TestLabels<std::list<std::string>, std::vector<MyStringView>>();
-    TestLabels<std::list<std::string>, std::array<MyStringView, 3>>();
-
-    TestLabels<std::vector<std::string>, std::list<MyStringView>>();
-    TestLabels<std::vector<std::string>, std::vector<MyStringView>>();
-    TestLabels<std::vector<std::string>, std::array<MyStringView, 3>>();
-}
-
 TEST_F(MVariableTest, dump) {
     std::string old_bvar_dump_interval;
     std::string old_mbvar_dump;
@@ -302,7 +190,6 @@ TEST_F(MVariableTest, dump) {
 }
 
 TEST_F(MVariableTest, test_describe_exposed) {
-    std::list<std::string> labels_value1 {"bj", "get", "200"};
     std::string bvar_name("request_count_describe");
     bvar::MultiDimension<bvar::Adder<int> > my_madder1(bvar_name, labels);