src/share/vm/memory/gcLocker.hpp

@@ -52,39 +52,31 @@
   // currently in a critical region.  It's only kept up to date when
   // _needs_gc is true.  The current value is computed during
   // safepointing and decremented during the slow path of GC_locker
   // unlocking.
   static volatile jint _jni_lock_count;  // number of jni active instances.
-
-  static volatile jint _lock_count;      // number of other active instances
   static volatile bool _needs_gc;        // heap is filling, we need a GC
                                          // note: bool is typedef'd as jint
   static volatile bool _doing_gc;        // unlock_critical() is doing a GC
 
 #ifdef ASSERT
   // This lock count is updated for all operations and is used to
   // validate the jni_lock_count that is computed during safepoints.
   static volatile jint _debug_jni_lock_count;
 #endif
 
-  // Accessors
-  static bool is_jni_active() {
-    assert(_needs_gc, "only valid when _needs_gc is set");
-    return _jni_lock_count > 0;
-  }
-
   // At a safepoint, visit all threads and count the number of active
   // critical sections.  This is used to ensure that all active
   // critical sections are exited before a new one is started.
   static void verify_critical_count() NOT_DEBUG_RETURN;
 
   static void jni_lock(JavaThread* thread);
   static void jni_unlock(JavaThread* thread);
 
   static bool is_active_internal() {
     verify_critical_count();
-    return _lock_count > 0 || _jni_lock_count > 0;
+    return _jni_lock_count > 0;
   }
 
  public:
   // Accessors
   static bool is_active() {

@@ -130,14 +122,10 @@
   // JNICritical_lock, so the caller may not safely assert upon
   // return from this method that "!needs_gc()" since that is
   // not a stable predicate.
   static void stall_until_clear();
 
-  // Non-structured GC locking: currently needed for JNI. Use with care!
-  static void lock();
-  static void unlock();
-
   // The following two methods are used for JNI critical regions.
   // If we find that we failed to perform a GC because the GC_locker
   // was active, arrange for one as soon as possible by allowing
   // all threads in critical regions to complete, but not allowing
   // other critical regions to be entered. The reasons for that are: