JVM源码分析之堆外内存完全解读

DirectByteBuffer(int cap) {                   // package-private      super(-1, 0, cap, cap);     boolean pa = VM.isDirectMemoryPageAligned();     int ps = Bits.pageSize();     long size = Math.max(1L, (long)cap + (pa ? ps : 0));     Bits.reserveMemory(size, cap);      long base = 0;     try {         base = unsafe.allocateMemory(size);     } catch (OutOfMemoryError x) {         Bits.unreserveMemory(size, cap);         throw x;     }     unsafe.setMemory(base, size, (byte) 0);     if (pa && (base % ps != 0)) {         // Round up to page boundary         address = base + ps - (base & (ps - 1));     } else {         address = base;     }     cleaner = Cleaner.create(this, new Deallocator(base, size, cap));     att = null;    }

     static void reserveMemory(long size, int cap) {         synchronized (Bits.class) {             if (!memoryLimitSet && VM.isBooted()) {                 maxMemory = VM.maxDirectMemory();                 memoryLimitSet = true;             }             // -XX:MaxDirectMemorySize limits the total capacity rather than the             // actual memory usage, which will differ when buffers are page             // aligned.             if (cap <= maxMemory - totalCapacity) {                 reservedMemory += size;                 totalCapacity += cap;                 count++;                 return;             }         }          System.gc();         try {             Thread.sleep(100);         } catch (InterruptedException x) {             // Restore interrupt status             Thread.currentThread().interrupt();         }         synchronized (Bits.class) {             if (totalCapacity + cap > maxMemory)                 throw new OutOfMemoryError("Direct buffer memory");             reservedMemory += size;             totalCapacity += cap;             count++;         }      }

 private static long directMemory = 64 * 1024 * 1024;      // Returns the maximum amount of allocatable direct buffer memory.     // The directMemory variable is initialized during system initialization     // in the saveAndRemoveProperties method.     //     public static long maxDirectMemory() {         return directMemory;     }

 /**      * Initialize the system class.  Called after thread initialization.      */     private static void initializeSystemClass() {          // VM might invoke JNU_NewStringPlatform() to set those encoding         // sensitive properties (user.home, user.name, boot.class.path, etc.)         // during "props" initialization, in which it may need access, via         // System.getProperty(), to the related system encoding property that         // have been initialized (put into "props") at early stage of the         // initialization. So make sure the "props" is available at the         // very beginning of the initialization and all system properties to         // be put into it directly.         props = new Properties();         initProperties(props);  // initialized by the VM          // There are certain system configurations that may be controlled by         // VM options such as the maximum amount of direct memory and         // Integer cache size used to support the object identity semantics         // of autoboxing.  Typically, the library will obtain these values         // from the properties set by the VM.  If the properties are for         // internal implementation use only, these properties should be         // removed from the system properties.         //         // See java.lang.Integer.IntegerCache and the         // sun.misc.VM.saveAndRemoveProperties method for example.         //         // Save a private copy of the system properties object that         // can only be accessed by the internal implementation.  Remove         // certain system properties that are not intended for public access.         sun.misc.VM.saveAndRemoveProperties(props);         ......                 sun.misc.VM.booted();     }

     public static void saveAndRemoveProperties(Properties props) {         if (booted)             throw new IllegalStateException("System initialization has completed");          savedProps.putAll(props);          // Set the maximum amount of direct memory.  This value is controlled         // by the vm option -XX:MaxDirectMemorySize=<size>.         // The maximum amount of allocatable direct buffer memory (in bytes)         // from the system property sun.nio.MaxDirectMemorySize set by the VM.         // The system property will be removed.         String s = (String)props.remove("sun.nio.MaxDirectMemorySize");         if (s != null) {             if (s.equals("-1")) {                 // -XX:MaxDirectMemorySize not given, take default                 directMemory = Runtime.getRuntime().maxMemory();             } else {                 long l = Long.parseLong(s);                 if (l > -1)                     directMemory = l;             }         }          // Check if direct buffers should be page aligned         s = (String)props.remove("sun.nio.PageAlignDirectMemory");         if ("true".equals(s))             pageAlignDirectMemory = true;          // Set a boolean to determine whether ClassLoader.loadClass accepts         // array syntax.  This value is controlled by the system property         // "sun.lang.ClassLoader.allowArraySyntax".         s = props.getProperty("sun.lang.ClassLoader.allowArraySyntax");         allowArraySyntax = (s == null                                ? defaultAllowArraySyntax                                : Boolean.parseBoolean(s));          // Remove other private system properties         // used by java.lang.Integer.IntegerCache         props.remove("java.lang.Integer.IntegerCache.high");          // used by java.util.zip.ZipFile         props.remove("sun.zip.disableMemoryMapping");          // used by sun.launcher.LauncherHelper         props.remove("sun.java.launcher.diag");     }

JNIEXPORT jlong JNICALL Java_java_lang_Runtime_maxMemory(JNIEnv *env, jobject this) {     return JVM_MaxMemory(); }  JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))   JVMWrapper("JVM_MaxMemory");   size_t n = Universe::heap()->max_capacity();   return convert_size_t_to_jlong(n); JVM_END 

size_t GenCollectedHeap::max_capacity() const {   size_t res = 0;   for (int i = 0; i < _n_gens; i++) {     res += _gens[i]->max_capacity();   }   return res; }  size_t DefNewGeneration::max_capacity() const {   const size_t alignment = GenCollectedHeap::heap()->collector_policy()->min_alignment();   const size_t reserved_bytes = reserved().byte_size();   return reserved_bytes - compute_survivor_size(reserved_bytes, alignment); }  size_t Generation::max_capacity() const {   return reserved().byte_size(); }

 private static class ReferenceHandler extends Thread {          ReferenceHandler(ThreadGroup g, String name) {             super(g, name);         }          public void run() {             for (;;) {                  Reference r;                 synchronized (lock) {                     if (pending != null) {                         r = pending;                         Reference rn = r.next;                         pending = (rn == r) ? null : rn;                         r.next = r;                     } else {                         try {                             lock.wait();                         } catch (InterruptedException x) { }                         continue;                     }                 }                  // Fast path for cleaners                 if (r instanceof Cleaner) {                     ((Cleaner)r).clean();                     continue;                 }                  ReferenceQueue q = r.queue;                 if (q != ReferenceQueue.NULL) q.enqueue(r);             }         }     }

void VM_GC_Operation::doit_epilogue() {   assert(Thread::current()->is_Java_thread(), "just checking");   // Release the Heap_lock first.   SharedHeap* sh = SharedHeap::heap();   if (sh != NULL) sh->_thread_holds_heap_lock_for_gc = false;   Heap_lock->unlock();   release_and_notify_pending_list_lock(); }  void VM_GC_Operation::release_and_notify_pending_list_lock() { instanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock); }