diff --git a/src/heap.h b/src/heap.h
index c25803f..aa9db6e 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -40,6 +40,7 @@
   static const size_t kMaximumSize = 16 * MB;
 
   typedef void (RootVisitor)(const Object* root, void* arg);
+  typedef bool (IsMarkedTester)(const Object* object, void* arg);
 
   // Create a heap with the requested sizes. The possible empty
   // image_file_names names specify Spaces to load based on
diff --git a/src/intern_table.cc b/src/intern_table.cc
index aa27ace..53208fd 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -119,11 +119,12 @@
   return found == s;
 }
 
-void InternTable::RemoveWeakIf(const Predicate& predicate) {
+void InternTable::SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg) {
   MutexLock mu(intern_table_lock_);
   typedef Table::const_iterator It; // TODO: C++0x auto
   for (It it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
-    if (predicate(it->second)) {
+    Object* object = it->second;
+    if (!is_marked(object, arg)) {
       weak_interns_.erase(it++);
     } else {
       ++it;
diff --git a/src/intern_table.h b/src/intern_table.h
index c814a1b..d573538 100644
--- a/src/intern_table.h
+++ b/src/intern_table.h
@@ -41,14 +41,7 @@
   // Used when reinitializing InternTable from an image.
   void RegisterStrong(String* s);
 
-  // Removes all weak interns for which the predicate functor 'p' returns true.
-  // (We use an explicit Predicate type rather than a template to keep implementation
-  // out of the header file.)
-  struct Predicate {
-    virtual ~Predicate() {}
-    virtual bool operator()(const String*) const = 0;
-  };
-  void RemoveWeakIf(const Predicate& p);
+  void SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg);
 
   bool ContainsWeak(String* s);
 
diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index 3f9fab0..d9a6a45 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -36,9 +36,9 @@
   EXPECT_EQ(2U, t.Size());
 }
 
-class TestPredicate : public InternTable::Predicate {
+class TestPredicate {
  public:
-  bool operator()(const String* s) const {
+  bool IsMarked(const Object* s) const {
     bool erased = false;
     typedef std::vector<const String*>::iterator It; // TODO: C++0x auto
     for (It it = expected_.begin(), end = expected_.end(); it != end; ++it) {
@@ -49,7 +49,7 @@
       }
     }
     EXPECT_TRUE(erased);
-    return true;
+    return false;
   }
 
   void Expect(const String* s) {
@@ -64,7 +64,11 @@
   mutable std::vector<const String*> expected_;
 };
 
-TEST_F(InternTableTest, RemoveWeakIf) {
+bool IsMarked(const Object* object, void* arg) {
+  return reinterpret_cast<TestPredicate*>(arg)->IsMarked(object);
+}
+
+TEST_F(InternTableTest, SweepInternTableWeaks) {
   InternTable t;
   t.InternStrong(3, "foo");
   t.InternStrong(3, "bar");
@@ -77,7 +81,7 @@
   TestPredicate p;
   p.Expect(s0);
   p.Expect(s1);
-  t.RemoveWeakIf(p);
+  t.SweepInternTableWeaks(IsMarked, &p);
 
   EXPECT_EQ(2U, t.Size());
 
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 05f229d..79597ec 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -13,6 +13,7 @@
 #include "logging.h"
 #include "macros.h"
 #include "mark_stack.h"
+#include "monitor.h"
 #include "object.h"
 #include "runtime.h"
 #include "space.h"
@@ -125,24 +126,9 @@
   }
 }
 
-struct InternTableEntryIsUnmarked : public InternTable::Predicate {
-  InternTableEntryIsUnmarked(MarkSweep* ms) : ms_(ms) { }
-
-  bool operator()(const String* s) const {
-    return !ms_->IsMarked(s);
-  }
-
-  MarkSweep* ms_;
-};
-
-void MarkSweep::SweepMonitorList() {
-  UNIMPLEMENTED(WARNING);
-  //dvmSweepMonitorList(&gDvm.monitorList, isUnmarkedObject);
-}
-
 void MarkSweep::SweepSystemWeaks() {
-  Runtime::Current()->GetInternTable()->RemoveWeakIf(InternTableEntryIsUnmarked(this));
-  SweepMonitorList();
+  Runtime::Current()->GetInternTable()->SweepInternTableWeaks(IsMarked, this);
+  Runtime::Current()->GetMonitorList()->SweepMonitorList(IsMarked, this);
   SweepJniWeakGlobals();
 }
 
diff --git a/src/mark_sweep.h b/src/mark_sweep.h
index cf099ad..bcb4df0 100644
--- a/src/mark_sweep.h
+++ b/src/mark_sweep.h
@@ -59,6 +59,10 @@
     return mark_bitmap_->Test(object);
   }
 
+  static bool IsMarked(const Object* object, void* arg) {
+    return reinterpret_cast<MarkSweep*>(arg)->IsMarked(object);
+  }
+
   static void MarkObjectVisitor(const Object* root, void* arg);
 
   // Marks an object.
@@ -112,7 +116,6 @@
                          Object** phantom_references);
 
   void SweepSystemWeaks();
-  void SweepMonitorList();
   void SweepJniWeakGlobals();
 
   MarkStack* mark_stack_;
diff --git a/src/monitor.cc b/src/monitor.cc
index 9a0233f..bc577a4 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -26,6 +26,7 @@
 
 #include "mutex.h"
 #include "object.h"
+#include "stl_util.h"
 #include "thread.h"
 #include "thread_list.h"
 
@@ -94,6 +95,10 @@
 
 bool Monitor::is_verbose_ = false;
 
+bool Monitor::IsVerbose() {
+  return is_verbose_;
+}
+
 void Monitor::SetVerbose(bool is_verbose) {
   is_verbose_ = is_verbose;
 }
@@ -104,7 +109,6 @@
       obj_(obj),
       wait_set_(NULL),
       lock_("a monitor lock"),
-      next_(NULL),
       owner_filename_(NULL),
       owner_line_number_(0) {
 }
@@ -174,48 +178,8 @@
   }
 }
 
-// Global list of all monitors. Used for cleanup.
-static Monitor* gMonitorList = NULL;
-
-void Monitor::FreeMonitorList() {
-  Monitor* m = gMonitorList;
-  while (m != NULL) {
-    Monitor* next = m->next_;
-    delete m;
-    m = next;
-  }
-}
-
-/*
- * Frees monitor objects belonging to unmarked objects.
- */
-static void SweepMonitorList(Monitor** mon, bool (isUnmarkedObject)(void*)) {
-  UNIMPLEMENTED(FATAL);
-#if 0
-  Monitor handle;
-  Monitor *curr;
-
-  DCHECK(mon != NULL);
-  DCHECK(isUnmarkedObject != NULL);
-  Monitor* prev = &handle;
-  prev->next = curr = *mon;
-  while (curr != NULL) {
-    Object* obj = curr->obj;
-    if ((*isUnmarkedObject)(obj) != 0) {
-      prev->next = curr->next;
-      delete curr;
-      curr = prev->next;
-    } else {
-      prev = curr;
-      curr = curr->next;
-    }
-  }
-  *mon = handle.next;
-#endif
-}
-
-void Monitor::SweepMonitorList(bool (isUnmarkedObject)(void*)) {
-  ::art::SweepMonitorList(&gMonitorList, isUnmarkedObject);
+Object* Monitor::GetObject() {
+  return obj_;
 }
 
 /*
@@ -648,10 +612,7 @@
   if (is_verbose_) {
     LOG(INFO) << "monitor: created monitor " << m << " for object " << obj;
   }
-  // Replace the head of the list with the new monitor.
-  do {
-    m->next_ = gMonitorList;
-  } while (android_atomic_release_cas((int32_t)m->next_, (int32_t)m, (int32_t*)(void*)&gMonitorList) != 0);
+  Runtime::Current()->GetMonitorList()->Add(m);
   m->Lock(self);
   // Propagate the lock state.
   uint32_t thin = *obj->GetRawLockWordAddress();
@@ -945,4 +906,35 @@
   os << "\n";
 }
 
+MonitorList::MonitorList() : lock_("MonitorList lock") {
+}
+
+MonitorList::~MonitorList() {
+  MutexLock mu(lock_);
+  STLDeleteElements(&list_);
+}
+
+void MonitorList::Add(Monitor* m) {
+  MutexLock mu(lock_);
+  list_.push_front(m);
+}
+
+void MonitorList::SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg) {
+  MutexLock mu(lock_);
+  typedef std::list<Monitor*>::iterator It; // TODO: C++0x auto
+  It it = list_.begin();
+  while (it != list_.end()) {
+    Monitor* m = *it;
+    if (!is_marked(m->GetObject(), arg)) {
+      if (Monitor::IsVerbose()) {
+        LOG(INFO) << "freeing monitor " << m << " belonging to unmarked object " << m->GetObject();
+      }
+      delete m;
+      it = list_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace art
diff --git a/src/monitor.h b/src/monitor.h
index 9ea407e..1316532 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -21,7 +21,9 @@
 #include <stdint.h>
 
 #include <iosfwd>
+#include <list>
 
+#include "heap.h"
 #include "mutex.h"
 
 namespace art {
@@ -60,6 +62,7 @@
  public:
   ~Monitor();
 
+  static bool IsVerbose();
   static void SetVerbose(bool is_verbose);
 
   static uint32_t GetLockOwner(uint32_t raw_lock_word);
@@ -71,12 +74,10 @@
   static void NotifyAll(Thread* self, Object* obj);
   static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow);
 
-  static void SweepMonitorList(bool (isUnmarkedObject)(void*));
-
-  static void FreeMonitorList();
-
   static void DescribeWait(std::ostream& os, const Thread* thread);
 
+  Object* GetObject();
+
  private:
   Monitor(Object* obj);
 
@@ -109,8 +110,6 @@
 
   Mutex lock_;
 
-  Monitor* next_;
-
   /*
    * Who last acquired this monitor, when lock sampling is enabled.
    * Even when enabled, ownerFileName may be NULL.
@@ -119,6 +118,23 @@
   uint32_t owner_line_number_;
 
   friend class Object;
+  DISALLOW_COPY_AND_ASSIGN(Monitor);
+};
+
+class MonitorList {
+ public:
+  MonitorList();
+  ~MonitorList();
+
+  void Add(Monitor* m);
+
+  void SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg);
+
+ private:
+  Mutex lock_;
+  std::list<Monitor*> list_;
+
+  DISALLOW_COPY_AND_ASSIGN(MonitorList);
 };
 
 /*
diff --git a/src/runtime.cc b/src/runtime.cc
index e0c9d47..a707c4d 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -34,6 +34,7 @@
     : verbose_startup_(false),
       is_zygote_(false),
       default_stack_size_(Thread::kDefaultStackSize),
+      monitor_list_(NULL),
       thread_list_(NULL),
       intern_table_(NULL),
       class_linker_(NULL),
@@ -61,6 +62,7 @@
 
   // Make sure all other non-daemon threads have terminated, and all daemon threads are suspended.
   delete thread_list_;
+  delete monitor_list_;
 
   delete class_linker_;
   Heap::Destroy();
@@ -426,6 +428,7 @@
 
   default_stack_size_ = options->stack_size_;
 
+  monitor_list_ = new MonitorList;
   thread_list_ = new ThreadList(options->IsVerbose("thread"));
   intern_table_ = new InternTable;
 
diff --git a/src/runtime.h b/src/runtime.h
index 462bb81..84302a9 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -31,6 +31,7 @@
 class InternTable;
 class JavaVMExt;
 class Method;
+class MonitorList;
 class SignalCatcher;
 class String;
 class ThreadList;
@@ -140,6 +141,10 @@
     return properties_;
   }
 
+  MonitorList* GetMonitorList() const {
+    return monitor_list_;
+  }
+
   ThreadList* GetThreadList() const {
     return thread_list_;
   }
@@ -230,6 +235,8 @@
   // The default stack size for managed threads created by the runtime.
   size_t default_stack_size_;
 
+  MonitorList* monitor_list_;
+
   ThreadList* thread_list_;
 
   InternTable* intern_table_;