Add ThreadIterator for iterating over all Threads

runtime/vm/thread.h

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_THREAD_H_
 #define VM_THREAD_H_
 
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/os_thread.h"
@@ skipping 395 matching lines @@
 
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_VARIABLE(object)                                 \
   bool reusable_##object##_handle_scope_active_;
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_VARIABLE);
 #undef REUSABLE_HANDLE_SCOPE_VARIABLE
 #endif  // defined(DEBUG)
 
   VMHandles reusable_handles_;
 
+  // All |Thread|s are registered in the thread list.
+  Thread* thread_list_next_;
+
+  static Thread* thread_list_head_;
+  static Mutex thread_list_lock_;

[siva, 2015/10/12 23:03:14]

In general we avoid declaring a static Mutex like this as the order in which
static destructors are run by the C++ compiler can lead to race conditions where
we might be shutting down the VM, e.g: calling RemoveThreadFromList after this
mutex has been destroyed.

Maybe change to
static Mutext* thread_list_lock_ and inside
Thread::InitOnceBeforeIsolate() add a line
thread_list_lock_ = new Mutex();

and delete it in Dart::Cleanup

[Cutch, 2015/10/13 16:41:23]

Done.

+
+  static void AddThreadToList(Thread* thread);
+  static void RemoveThreadFromList(Thread* thread);

[siva, 2015/10/12 23:03:14]

these functions should be private functions to ensure that it is only called
from Thread() and ~Thread() and not from any random place?

[Cutch, 2015/10/13 16:41:24]

These are private.

+
   explicit Thread(bool init_vm_constants = true);
 
   void InitVMConstants();
 
   void ClearState() {
     memset(&state_, 0, sizeof(state_));
   }
 
   void StoreBufferRelease(
       StoreBuffer::ThresholdPolicy policy = StoreBuffer::kCheckThreshold);
@@ skipping 13 matching lines @@
   void Unschedule(bool bypass_safepoint = false);
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
   friend class ApiZone;
   friend class Isolate;
   friend class StackZone;
+  friend class ThreadIterator;
+  friend class ThreadIteratorTestHelper;
   friend class ThreadRegistry;
+
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
+
+// Note that this takes the thread list lock, prohibiting threads from coming
+// on- or off-line.
+class ThreadIterator : public ValueObject {
+ public:
+  ThreadIterator();
+  ~ThreadIterator();
+
+  // Returns false when there are no more threads left.
+  bool HasNext();

[siva, 2015/10/12 23:03:14]

bool HasNext() const;

[Cutch, 2015/10/13 16:41:24]

Done.

+
+  // Returns the current thread and moves forward.
+  Thread* Next();
+
+ private:
+  Thread* next_;
+};
+
 }  // namespace dart
 
 #endif  // VM_THREAD_H_