diff --git a/common/lockfree_queue.h b/common/lockfree_queue.h
index 7fda6da9..098c194c 100644
--- a/common/lockfree_queue.h
+++ b/common/lockfree_queue.h
@@ -20,7 +20,7 @@ limitations under the License.
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <mutex>
+#include <memory>
 #include <thread>
 #include <utility>
 #ifndef __aarch64__
@@ -90,16 +90,23 @@ struct PhotonPause : PauseBase {
     }
 };
 
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+template <typename T>
+struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
 template <typename T, size_t N>
 class LockfreeRingQueueBase {
 public:
 #if __cplusplus < 201402L
-    static_assert(std::has_trivial_copy_constructor<T>::value &&
-                      std::has_trivial_copy_assign<T>::value,
+    static_assert((std::has_trivial_copy_constructor<T>::value &&
+                   std::has_trivial_copy_assign<T>::value) ||
+                      is_shared_ptr<T>::value,
                   "T should be trivially copyable");
 #else
-    static_assert(std::is_trivially_copy_constructible<T>::value &&
-                      std::is_trivially_copy_assignable<T>::value,
+    static_assert((std::is_trivially_copy_constructible<T>::value &&
+                   std::is_trivially_copy_assignable<T>::value) ||
+                      is_shared_ptr<T>::value,
                   "T should be trivially copyable");
 #endif
 
diff --git a/common/objectcachev2.h b/common/objectcachev2.h
new file mode 100644
index 00000000..0085e3f9
--- /dev/null
+++ b/common/objectcachev2.h
@@ -0,0 +1,258 @@
+#pragma once
+
+#include <photon/common/alog.h>
+#include <photon/common/lockfree_queue.h>
+#include <photon/photon.h>
+#include <photon/thread/list.h>
+#include <photon/thread/thread11.h>
+#include <photon/thread/timer.h>
+#include <photon/thread/workerpool.h>
+
+#include <memory>
+#include <unordered_set>
+
+/**
+
+A simpler but effective object cache implementation.
+
+`ObjectCacheV2` shows better performance compare to `ObjectCache`, with several
+improvements:
+
+1. Less lock in both read and write.
+2. Object destruction always goes in background photon thread called reclaimer.
+3. Self adjustable timeout for reclaimer. No needs to set cycler timer.
+4. New `update` API, able to immediately substitute objects.
+5. `ObjectCacheV2` no longer support acquire/release API.
+
+It should work as `ObjectCache` in code do not depends on acquire/release API.
+
+**/
+
+template <typename K, typename VPtr>
+class ObjectCacheV2 {
+protected:
+    using V = std::remove_pointer_t<VPtr>;
+
+    struct Box : public intrusive_list_node<Box> {
+        const K key;
+        std::shared_ptr<V> ref;
+        photon::spinlock boxlock;
+        uint64_t lastcreate = 0;
+        uint64_t timestamp = 0;
+
+        struct Updater {
+            Box* box = nullptr;
+
+            ~Updater() {}
+
+            // Returned RefPtr is the old one
+            // other reader will get new one after updated
+
+            std::shared_ptr<V> update(std::shared_ptr<V>& r, uint64_t ts = 0) {
+                box->lastcreate = ts;
+                r = std::atomic_exchange(&box->ref, r);
+                return r;
+            }
+            std::shared_ptr<V> update(V* val, uint64_t ts = 0,
+                                      std::shared_ptr<V>* newptr = nullptr) {
+                auto r = std::shared_ptr<V>(val);
+                if (newptr) *newptr = r;
+                return update(r, ts);
+            }
+
+            explicit Updater(Box* b) : box(b) {}
+
+            Updater(const Updater&) = delete;
+            Updater(Updater&& rhs) : box(nullptr) { *this = std::move(rhs); }
+            Updater& operator=(const Updater&) = delete;
+            Updater& operator=(Updater&& rhs) {
+                std::swap(box, rhs.box);
+                return *this;
+            }
+            operator bool() const { return box != nullptr; }
+        };
+
+        Box() = default;
+        template <typename KeyType>
+        explicit Box(KeyType&& key)
+            : key(std::forward<KeyType>(key)), ref(nullptr) {}
+
+        ~Box() {}
+
+        Updater writer() { return Updater(this); }
+        std::shared_ptr<V> reader() { return std::atomic_load(&ref); }
+    };
+    struct ItemHash {
+        size_t operator()(const Box& x) const { return std::hash<K>()(x.key); }
+    };
+    struct ItemEqual {
+        bool operator()(const Box& a, const Box& b) const {
+            return a.key == b.key;
+        }
+    };
+
+    photon::thread* reclaimer = nullptr;
+    photon::common::RingChannel<LockfreeMPMCRingQueue<std::shared_ptr<V>, 4096>>
+        reclaim_queue;
+    photon::spinlock maplock;
+    std::unordered_set<Box, ItemHash, ItemEqual> map;
+    intrusive_list<Box> cycle_list;
+    uint64_t lifespan;
+    photon::Timer _timer;
+    bool _exit = false;
+
+    std::shared_ptr<V> __update(Box& item, std::shared_ptr<V> val) {
+        auto ret_val = val;
+        auto old_val = item.writer().update(val, photon::now);
+        reclaim_queue.template send<PhotonPause>(old_val);
+        return ret_val;
+    }
+
+    std::shared_ptr<V> __update(Box& item, V* val) {
+        std::shared_ptr<V> ptr(val);
+        return __update(item, ptr);
+    }
+
+    template <typename KeyType>
+    Box& __find_or_create_item(KeyType&& key) {
+        Box keyitem(key);
+        Box* item = nullptr;
+        SCOPED_LOCK(maplock);
+        auto it = map.find(keyitem);
+        if (it == map.end()) {
+            // item = new Box(std::forward<KeyType>(key));
+            auto rt = map.emplace(key);
+            if (rt.second) item = (Box*)&*rt.first;
+        } else
+            item = (Box*)&*it;
+        assert(item);
+        item->timestamp = photon::now;
+        cycle_list.pop(item);
+        cycle_list.push_back(item);
+        return *item;
+    }
+
+    uint64_t __expire() {
+        intrusive_list<Box> delete_list;
+        uint64_t now = photon::now;
+        {
+            SCOPED_LOCK(maplock);
+            if (cycle_list.empty()) return 0;
+            if (photon::sat_add(cycle_list.front()->timestamp, lifespan) >
+                now) {
+                return photon::sat_add(cycle_list.front()->timestamp,
+                                       lifespan) -
+                       now;
+            }
+            auto x = cycle_list.front();
+            while (x && (photon::sat_add(x->timestamp, lifespan) < now)) {
+                cycle_list.pop(x);
+                __update(*x, nullptr);
+                map.erase(*x);
+                x = cycle_list.front();
+            }
+        }
+        return 0;
+    }
+
+public:
+    struct Borrow {
+        ObjectCacheV2* _oc = nullptr;
+        Box* _item = nullptr;
+        std::shared_ptr<V> _reader;
+        bool _recycle = false;
+
+        Borrow() : _reader(nullptr) {}
+
+        Borrow(ObjectCacheV2* oc, Box* item, std::shared_ptr<V>&& reader)
+            : _oc(oc),
+              _item(item),
+              _reader(std::move(reader)),
+              _recycle(false) {}
+
+        Borrow(Borrow&& rhs) : _reader(nullptr) { *this = std::move(rhs); }
+
+        Borrow& operator=(Borrow&& rhs) {
+            std::swap(_oc, rhs._oc);
+            std::swap(_item, rhs._item);
+            _reader = std::atomic_exchange(&rhs._reader, _reader);
+            std::swap(_reader, rhs._reader);
+            std::swap(_recycle, rhs._recycle);
+            return *this;
+        }
+
+        ~Borrow() {
+            if (_recycle) {
+                _oc->__update(*_item, nullptr);
+            }
+        }
+
+        bool recycle() { return _recycle; }
+
+        bool recycle(bool x) { return _recycle = x; }
+
+        V& operator*() const { return *_reader; }
+        V* operator->() const { return &*_reader; }
+        operator bool() const { return (bool)_reader; }
+    };
+
+    template <typename KeyType, typename Ctor>
+    Borrow borrow(KeyType&& key, Ctor&& ctor, uint64_t cooldown = 0UL) {
+        auto& item = __find_or_create_item(std::forward<KeyType>(key));
+        auto r = item.reader();
+        while (!r) {
+            if (item.boxlock.try_lock() == 0) {
+                DEFER(item.boxlock.unlock());
+                r = item.reader();
+                if (!r) {
+                    if (photon::sat_add(item.lastcreate, cooldown) <=
+                        photon::now) {
+                        r = __update(item, ctor());
+                    }
+                    return Borrow(this, &item, std::move(r));
+                }
+            }
+            photon::thread_yield();
+            r = item.reader();
+        }
+        return Borrow(this, &item, std::move(r));
+    }
+
+    template <typename KeyType>
+    Borrow borrow(KeyType&& key) {
+        return borrow(std::forward<KeyType>(key),
+                      [&]() { return std::make_shared<V>(); });
+    }
+
+    template <typename KeyType, typename Ctor>
+    Borrow update(KeyType&& key, Ctor&& ctor) {
+        auto item = __find_or_create_item(std::forward<KeyType>(key));
+        auto r = __update(item, ctor());
+        return Borrow(this, item, std::move(r));
+    }
+
+    ObjectCacheV2(uint64_t lifespan)
+        : lifespan(lifespan),
+          _timer(1UL * 1000 * 1000, {this, &ObjectCacheV2::__expire}, true,
+                 photon::DEFAULT_STACK_SIZE),
+          _exit(false) {
+        reclaimer = photon::thread_create11([this] {
+            while (!_exit) {
+                reclaim_queue.recv();
+            }
+        });
+        photon::thread_enable_join(reclaimer);
+    }
+
+    ~ObjectCacheV2() {
+        _timer.stop();
+        if (reclaimer) {
+            _exit = true;
+            reclaim_queue.template send<PhotonPause>(nullptr);
+            photon::thread_join((photon::join_handle*)reclaimer);
+            reclaimer = nullptr;
+        }
+        SCOPED_LOCK(maplock);
+        cycle_list.node = nullptr;
+    }
+};
\ No newline at end of file
diff --git a/common/test/CMakeLists.txt b/common/test/CMakeLists.txt
index 71871cc0..1a30526c 100644
--- a/common/test/CMakeLists.txt
+++ b/common/test/CMakeLists.txt
@@ -5,6 +5,10 @@ add_executable(test-objcache test_objcache.cpp)
 target_link_libraries(test-objcache PRIVATE photon_shared)
 add_test(NAME test-objcache COMMAND $<TARGET_FILE:test-objcache>)
 
+add_executable(perf-objcache perf_objcache.cpp)
+target_link_libraries(perf-objcache PRIVATE photon_shared)
+add_test(NAME perf-objcache COMMAND $<TARGET_FILE:test-objcache>)
+
 add_executable(test-common test.cpp)
 target_link_libraries(test-common PRIVATE photon_shared)
 add_test(NAME test-common COMMAND $<TARGET_FILE:test-common>)
diff --git a/common/test/perf_objcache.cpp b/common/test/perf_objcache.cpp
index 5832c245..71a7e558 100644
--- a/common/test/perf_objcache.cpp
+++ b/common/test/perf_objcache.cpp
@@ -2,16 +2,15 @@
 #include <photon/photon.h>
 #include <photon/thread/thread.h>
 
+#include <algorithm>
 #include <array>
 #include <chrono>
 #include <random>
 #include <thread>
-#include <unordered_map>
 #include <vector>
-#include <algorithm>
-#include "../../test/ci-tools.h"
 
 #include "../expirecontainer.h"
+#include "../objectcachev2.h"
 
 constexpr size_t count = 10UL * 1024;
 
@@ -29,51 +28,64 @@ void ready() {
     LOG_INFO("Random key generated");
 }
 
+template <template <class, class> class OC>
 void *task(void *arg) {
-    auto oc = (ObjectCache<std::string, std::string *> *)arg;
+    auto oc = (OC<std::string, std::string *> *)arg;
     std::array<uint64_t, count> k = keys;
-    std::random_shuffle(k.begin(), k.end());
+    std::random_device rd;
+    std::mt19937 g(rd());
+    std::shuffle(k.begin(), k.end(), g);
 
+    auto start = std::chrono::steady_clock::now();
     for (const auto &x : k) {
         auto strx = std::to_string(x);
         auto b = oc->borrow(strx, [&strx] {
-            photon::thread_usleep(1 * 1000);
+            // photon::thread_usleep(1 * 1000);
             // LOG_INFO("CTOR `", photon::now);
             return new std::string(strx);
         });
     }
+    auto done = std::chrono::steady_clock::now();
+    LOG_INFO("spent ` ms",
+             std::chrono::duration_cast<std::chrono::milliseconds>(done - start)
+                 .count());
     return nullptr;
 }
 
-void test_objcache(ObjectCache<std::string, std::string *> &oc) {
+template <template <class, class> class OC>
+void test_objcache(OC<std::string, std::string *> &oc, const char *name) {
     std::vector<photon::join_handle *> jhs;
-    LOG_INFO("Query to ObjectCache");
-    auto start = std::chrono::steady_clock::now();
+    LOG_INFO("Query to ", name);
     for (int i = 0; i < 4; i++)
         jhs.emplace_back(
-            photon::thread_enable_join(photon::thread_create(task, &oc)));
+            photon::thread_enable_join(photon::thread_create(task<OC>, &oc)));
     for (auto &x : jhs) photon::thread_join(x);
-    auto done = std::chrono::steady_clock::now();
-    LOG_INFO("spent ` ms",
-             std::chrono::duration_cast<std::chrono::milliseconds>(done - start)
-                 .count());
 }
 
-int main() {
-    photon::init(0, 0);
-    DEFER(photon::fini());
-    ObjectCache<std::string, std::string *> oc(-1UL);
-    ready();
+template <template <class, class> class OC>
+void test(const char *name) {
+    OC<std::string, std::string *> oc(0);
     std::vector<std::thread> ths;
+    photon::semaphore sem(0);
     for (int i = 0; i < 10; i++) {
         ths.emplace_back([&] {
-            photon::init(0, 0);
-            DEFER(photon::fini());
-            test_objcache(oc);
+            photon::vcpu_init();
+            DEFER(photon::vcpu_fini());
+            test_objcache<OC>(oc, name);
+            sem.signal(1);
         });
     }
+    sem.wait(10);
     for (auto &x : ths) {
         x.join();
     }
+}
+
+int main() {
+    photon::vcpu_init();
+    DEFER(photon::vcpu_fini());
+    ready();
+    test<ObjectCache>("ObjectCache");
+    test<ObjectCacheV2>("ObjectCacheV2");
     return 0;
 }
\ No newline at end of file
diff --git a/common/test/test_objcache.cpp b/common/test/test_objcache.cpp
index 0d908e3a..16e206a0 100644
--- a/common/test/test_objcache.cpp
+++ b/common/test/test_objcache.cpp
@@ -18,6 +18,7 @@ limitations under the License.
 #define private public
 
 #include "../expirecontainer.h"
+#include "../objectcachev2.h"
 
 #undef private
 #undef protected
@@ -283,6 +284,115 @@ TEST(ObjectCache, borrow_with_once) {
     EXPECT_EQ(2, count.load());
 }
 
+struct OCArgV2 {
+    ObjectCacheV2<int, ShowOnDtor*>* oc;
+    int id;
+    std::atomic<int>* count;
+};
+void* objcache_borrow_v2(void* arg) {
+    auto args = (OCArgV2*)arg;
+    auto oc = args->oc;
+    auto id = args->id;
+    auto ctor = [&]() { return new ShowOnDtor(id); };
+    // acquire every 10ms
+    photon::thread_usleep(10 * 1000UL * id);
+    {
+        auto ret = oc->borrow(0, ctor);
+        LOG_DEBUG("Acquired ", VALUE(id));
+        EXPECT_TRUE(ret);
+        // object holds for 50ms
+        photon::thread_usleep(50 * 1000UL);
+        if (id % 10 == 0) {
+            LOG_INFO("Cycle ", VALUE(id));
+            ret.recycle(true);
+        }
+    }
+    // every 10 objs will recycle
+    if (id % 10 == 0) cycle_cnt++;
+    LOG_DEBUG("Released ", VALUE(id));
+    return 0;
+}
+
+
+TEST(ObjectCacheV2, borrow) {
+    set_log_output_level(ALOG_INFO);
+    DEFER(set_log_output_level(ALOG_DEBUG));
+    ObjectCacheV2<int, ShowOnDtor*> ocache(1000UL * 1000 * 10);
+    cycle_cnt = 0;
+    release_cnt = 0;
+    // 10s, during the test, nothing will be free if not set recycle
+    std::vector<std::thread> ths;
+    for (int i = 0; i < 10; i++) {
+        ths.emplace_back([&] {
+            photon::vcpu_init();
+            DEFER(photon::vcpu_fini());
+            std::vector<photon::join_handle*> handles;
+            std::vector<OCArgV2> args;
+            for (int i = 0; i < 100; i++) {
+                args.emplace_back(OCArgV2({&ocache, i + 1}));
+            }
+            for (auto& arg : args) {
+                handles.emplace_back(photon::thread_enable_join(
+                    photon::thread_create(&objcache_borrow_v2, &arg)));
+            }
+            for (const auto& handle : handles) {
+                photon::thread_join(handle);
+            }
+        });
+    }
+    for (auto& x : ths) {
+        x.join();
+    }
+
+    EXPECT_EQ(cycle_cnt, release_cnt);
+}
+
+void* objcache_borrow_once_v2(void* arg) {
+    auto args = (OCArgV2*)arg;
+    auto oc = args->oc;
+    // auto id = args->id;
+    auto& count = *args->count;
+    auto ctor = [&]()->ShowOnDtor* {
+        // failed after 1s;
+        photon::thread_usleep(1000 * 1000UL);
+        count++;
+        return nullptr;
+    };
+    auto ret = oc->borrow(0, ctor, 1000UL * 1000);
+    (void)ret;
+    // every 10 objs will recycle
+    return 0;
+}
+
+TEST(ObjectCacheV2, borrow_with_once) {
+    set_log_output_level(ALOG_INFO);
+    DEFER(set_log_output_level(ALOG_DEBUG));
+    ObjectCacheV2<int, ShowOnDtor*> ocache(1000UL * 1000 * 10);
+    cycle_cnt = 0;
+    release_cnt = 0;
+    std::atomic<int> count(0);
+    // 10s, during the test, nothing will be free if not set recycle
+    std::vector<photon::join_handle*> handles;
+    std::vector<OCArgV2> args;
+    for (int i = 0; i < 100; i++) {
+        args.emplace_back(OCArgV2{&ocache, i + 1, &count});
+    }
+    for (auto& arg : args) {
+        handles.emplace_back(photon::thread_enable_join(
+            photon::thread_create(&objcache_borrow_once_v2, &arg)));
+    }
+    for (const auto& handle : handles) {
+        photon::thread_join(handle);
+    }
+    EXPECT_EQ(1, count.load());
+    ocache.borrow(0, [&] {
+        photon::thread_usleep(1000 * 1000UL);
+        count++;
+        return new ShowOnDtor(1);
+    });
+    EXPECT_EQ(2, count.load());
+}
+
 TEST(ExpireContainer, expire_container) {
     char key[10] = "hello";
     char key2[10] = "hello";
diff --git a/include/photon/common/objectcachev2.h b/include/photon/common/objectcachev2.h
new file mode 120000
index 00000000..83e0724c
--- /dev/null
+++ b/include/photon/common/objectcachev2.h
@@ -0,0 +1 @@
+../../../common/objectcachev2.h
\ No newline at end of file