diff --git a/common_components/heap/collector/marking_collector.cpp b/common_components/heap/collector/marking_collector.cpp
index 241f35a1681b566d433ae6ff8b52c66d429aa72d..a32a3b2ee0dd915612349730bd5a58965535880a 100755
--- a/common_components/heap/collector/marking_collector.cpp
+++ b/common_components/heap/collector/marking_collector.cpp
@@ -157,20 +157,16 @@ void MarkingCollector::ProcessMarkStack([[maybe_unused]] uint32_t threadIndex, P
     size_t nNewlyMarked = 0;
     WeakStack weakStack;
     auto visitor = CreateMarkingObjectRefFieldsVisitor(markStack, weakStack);
-    std::vector<BaseObject *> remarkStack;
-    auto fetchFromSatbBuffer = [this, &markStack, &remarkStack]() {
-        SatbBuffer::Instance().TryFetchOneRetiredNode(remarkStack);
-        bool needProcess = false;
-        while (!remarkStack.empty()) {
-            BaseObject *obj = remarkStack.back();
-            remarkStack.pop_back();
+    auto fetchFromSatbBuffer = [this, &markStack]() {
+        auto filter = [this](BaseObject* obj) {
             if (Heap::IsHeapAddress(obj) && (!MarkObject(obj))) {
-                markStack.Push(obj);
-                needProcess = true;
                 DLOG(TRACE, "tracing take from satb buffer: obj %p", obj);
+                return true;
+            } else {
+                return false;
             }
-        }
-        return needProcess;
+        };
+        return SatbBuffer::Instance().TryFetchOneRetiredNode(markStack, filter);
     };
     size_t iterationCnt = 0;
     constexpr size_t maxIterationLoopNum = 1000;
@@ -431,30 +427,27 @@ bool MarkingCollector::MarkSatbBuffer(GlobalMarkStack &globalMarkStack)
 {
     OHOS_HITRACE(HITRACE_LEVEL_COMMERCIAL, "CMCGC::MarkSatbBuffer", "");
     COMMON_PHASE_TIMER("MarkSatbBuffer");
-    auto visitSatbObj = [this, &globalMarkStack]() {
-        std::vector<BaseObject *> remarkStack;
-        auto func = [&remarkStack](Mutator& mutator) {
-            const SatbBuffer::TreapNode* node = mutator.GetSatbBufferNode();
-            if (node != nullptr) {
-                const_cast<SatbBuffer::TreapNode*>(node)->GetObjects(remarkStack);
-            }
-        };
-        MutatorManager::Instance().VisitAllMutators(func);
-        SatbBuffer::Instance().GetRetiredObjects(remarkStack);
 
-        LocalCollectStack collectStack(&globalMarkStack);
-        while (!remarkStack.empty()) { // LCOV_EXCL_BR_LINE
-            BaseObject* obj = remarkStack.back();
-            remarkStack.pop_back();
-            if (Heap::IsHeapAddress(obj) && !this->MarkObject(obj)) {
-                collectStack.Push(obj);
-                DLOG(TRACE, "satb buffer add obj %p", obj);
-            }
+    auto filter = [this](BaseObject* obj) {
+        if (Heap::IsHeapAddress(obj) && !this->MarkObject(obj)) {
+            DLOG(TRACE, "satb buffer add obj %p", obj);
+            return true;
+        } else {
+            return false;
         }
-        collectStack.Publish();
     };
 
-    visitSatbObj();
+    // gather all filtered objects in satb
+    LocalCollectStack collectStack(&globalMarkStack);
+    MutatorManager::Instance().VisitAllMutators([&collectStack, &filter](Mutator& mutator) {
+        const SatbBuffer::TreapNode* node = mutator.GetSatbBufferNode();
+        if (node != nullptr) {
+            const_cast<SatbBuffer::TreapNode*>(node)->GetObjects(collectStack, filter);
+        }
+    });
+    SatbBuffer::Instance().GetRetiredObjects(collectStack, filter);
+
+    collectStack.Publish();
     return true;
 }
 
diff --git a/common_components/mutator/satb_buffer.h b/common_components/mutator/satb_buffer.h
index 10783b4be9b86f031b3471bb9366529edbd61e6f..d0b0c891d8e18e193b9ec0175c723b421050ade3 100755
--- a/common_components/mutator/satb_buffer.h
+++ b/common_components/mutator/satb_buffer.h
@@ -19,6 +19,7 @@
 #include "common_components/common/page_pool.h"
 #include "common_components/common/mark_work_stack.h"
 #include "common_components/log/log.h"
+#include <functional>
 
 namespace common {
 // snapshot at the beginning buffer
@@ -52,17 +53,22 @@ public:
             *top_ = const_cast<BaseObject*>(obj);
             top_++;
         }
-        template<typename T>
-        void GetObjects(T& stack)
+        template<typename T, typename Filter = std::function<bool(const BaseObject*)>>
+        bool GetObjects(T& stack, Filter filter)
         {
             ASSERT_LOGF(top_ <= &container_[CONTAINER_CAPACITY_], "invalid node");
             std::lock_guard<std::mutex> lg(syncLock_);
             BaseObject** head = container_;
+            int count = 0;
             while (head != top_) {
-                stack.push_back(*head);
+                if (filter(*head)) {
+                    stack.Push(*head);
+                    count++;
+                }
                 head++;
             }
             Clear();
+            return count;
         }
 
     private:
@@ -233,29 +239,32 @@ public:
 
     void Fini() { ReclaimALLPages(); }
 
-    template<typename T>
-    void GetRetiredObjects(T& stack)
+    template<typename T, typename Filter = std::function<bool(const BaseObject*)>>
+    int GetRetiredObjects(T& stack, Filter filter)
     {
         TreapNode* head = retiredNodes_.PopAll();
+        int count = 0;
         while (head != nullptr) {
-            head->GetObjects(stack);
+            count += head->GetObjects(stack, filter);
             TreapNode* oldHead = head;
             head = head->next_;
             oldHead->Clear();
             freeNodes_.Push(oldHead);
         }
+        return count;
     }
 
-    template<typename T>
-    void TryFetchOneRetiredNode(T& stack)
+    template<typename T, typename Filter = std::function<bool(const BaseObject*)>>
+    int TryFetchOneRetiredNode(T& localStack, Filter filter)
     {
         TreapNode* node = retiredNodes_.Pop();
         if (!node) {
-            return;
+            return 0;
         }
-        node->GetObjects(stack);
-        node->Clear();
+        int count = node->GetObjects(localStack, filter);
         freeNodes_.Push(node);
+
+        return count;
     }
 
     void ClearBuffer()