--- old/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	2014-05-20 13:35:45.599988092 +0200
+++ new/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	2014-05-20 13:35:45.450553392 +0200
@@ -2173,12 +2173,6 @@
 }
 
 void G1CollectedHeap::stop() {
-#if 0
-  // Stopping concurrent worker threads is currently disabled until
-  // some bugs in concurrent mark has been resolve. Without fixing
-  // those bugs first we risk haning during VM exit when trying to
-  // stop these threads.
-
   // Abort any ongoing concurrent root region scanning and stop all
   // concurrent threads. We do this to make sure these threads do
   // not continue to execute and access resources (e.g. gclog_or_tty)
@@ -2186,7 +2180,6 @@
   _cm->root_regions()->abort();
   _cm->root_regions()->wait_until_scan_finished();
   stop_conc_gc_threads();
-#endif
 }
 
 size_t G1CollectedHeap::conservative_max_heap_alignment() {
--- old/src/share/vm/runtime/java.cpp	2014-05-20 13:35:46.330620156 +0200
+++ new/src/share/vm/runtime/java.cpp	2014-05-20 13:35:46.190620617 +0200
@@ -500,9 +500,6 @@
     os::infinite_sleep();
   }
 
-  // Stop any ongoing concurrent GC work
-  Universe::heap()->stop();
-
   // Terminate watcher thread - must before disenrolling any periodic task
   if (PeriodicTask::num_tasks() > 0)
     WatcherThread::stop();
@@ -517,10 +514,8 @@
   StatSampler::disengage();
   StatSampler::destroy();
 
-  // We do not need to explicitly stop concurrent GC threads because the
-  // JVM will be taken down at a safepoint when such threads are inactive --
-  // except for some concurrent G1 threads, see (comment in)
-  // Threads::destroy_vm().
+  // Stop concurrent GC threads
+  Universe::heap()->stop();
 
   // Print GC/heap related information.
   if (PrintGCDetails) {
--- old/src/share/vm/runtime/thread.cpp	2014-05-20 13:35:46.941067925 +0200
+++ new/src/share/vm/runtime/thread.cpp	2014-05-20 13:35:46.801237870 +0200
@@ -3966,14 +3966,8 @@
     // GC vm_operations can get caught at the safepoint, and the
     // heap is unparseable if they are caught. Grab the Heap_lock
     // to prevent this. The GC vm_operations will not be able to
-    // queue until after the vm thread is dead.
-    // After this point, we'll never emerge out of the safepoint before
-    // the VM exits, so concurrent GC threads do not need to be explicitly
-    // stopped; they remain inactive until the process exits.
-    // Note: some concurrent G1 threads may be running during a safepoint,
-    // but these will not be accessing the heap, just some G1-specific side
-    // data structures that are not accessed by any other threads but them
-    // after this point in a terminal safepoint.
+    // queue until after the vm thread is dead. After this point,
+    // we'll never emerge out of the safepoint before the VM exits.
 
     MutexLocker ml(Heap_lock);