Examples of java.lang.management.MemoryPoolMXBean

java.lang.management.MemoryPoolMXBean
me the usage threshold is supported for this pool. // Set the threshold to myThreshold above which no new tasks // should be taken. pool.setUsageThreshold(myThreshold); .... boolean lowMemory = false; while (true) { if (pool.isUsageThresholdExceeded()) { // potential low memory, so redistribute tasks to other VMs lowMemory = true; redistributeTasks(); // stop receiving new tasks stopReceivingTasks(); } else { if (lowMemory) { // resume receiving tasks lowMemory = false; resumeReceivingTasks(); } // processing outstanding task ... } // sleep for sometime try { Thread.sleep(sometime); } catch (InterruptedException e) { ... } }
The above example does not differentiate the case where the memory usage has temporarily dropped below the usage threshold from the case where the memory usage remains above the threshould between two iterations. The usage threshold count returned by the {@link #getUsageThresholdCount} methodcan be used to determine if the memory usage has returned below the threshold between two polls.
Below shows another example that takes some action if a memory pool is under low memory and ignores the memory usage changes during the action processing time.
```
 // Assume the usage threshold is supported for this pool. // Set the threshold to myThreshold which determines if  // the application will take some action under low memory condition. pool.setUsageThreshold(myThreshold); int prevCrossingCount = 0; while (true) { // A busy loop to detect when the memory usage   // has exceeded the threshold. while (!pool.isUsageThresholdExceeded() ||  pool.getUsageThresholdCount() == prevCrossingCount) { try { Thread.sleep(sometime) } catch (InterruptException e) { .... } } // Do some processing such as check for memory usage // and issue a warning .... // Gets the current threshold count. The busy loop will then // ignore any crossing of threshold happens during the processing. prevCrossingCount = pool.getUsageThresholdCount(); } 
```
Usage Threshold Notifications
Usage threshold notification will be emitted by {@link MemoryMXBean}. When the Java virtual machine detects that the memory usage of a memory pool has reached or exceeded the usage threshold the virtual machine will trigger the MemoryMXBean to emit an {@link MemoryNotificationInfo#MEMORY_THRESHOLD_EXCEEDED usage threshold exceeded notification}. Another usage threshold exceeded notification will not be generated until the usage has fallen below the threshold and then exceeded it again.
Below is an example code implementing the same logic as the first example above but using the usage threshold notification mechanism to detect low memory conditions instead of polling. In this example code, upon receiving notification, the notification listener notifies another thread to perform the actual action such as to redistribute outstanding tasks, stop receiving tasks, or resume receiving tasks. The handleNotification method should be designed to do a very minimal amount of work and return without delay to avoid causing delay in delivering subsequent notifications. Time-consuming actions should be performed by a separate thread. The notification listener may be invoked by multiple threads concurrently; so the tasks performed by the listener should be properly synchronized.
```
   class MyListener implements javax.management.NotificationListener { public void handleNotification(Notification notification, Object handback)  { String notifType = notification.getType(); if (notifType.equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED)) { // potential low memory, notify another thread // to redistribute outstanding tasks to other VMs // and stop receiving new tasks. lowMemory = true; notifyAnotherThread(lowMemory); } } } // Register MyListener with MemoryMXBean   MemoryMXBean mbean = ManagementFactory.getMemoryMXBean(); NotificationEmitter emitter = (NotificationEmitter) mbean; MyListener listener = new MyListener(); emitter.addNotificationListener(listener, null, null); // Assume this pool supports a usage threshold. // Set the threshold to myThreshold above which no new tasks // should be taken. pool.setUsageThreshold(myThreshold); // Usage threshold detection is enabled and notification will be  // handled by MyListener.  Continue for other processing. .... 
```
There is no guarantee about when the MemoryMXBean will emit a threshold notification and when the notification will be delivered. When a notification listener is invoked, the memory usage of the memory pool may have crossed the usage threshold more than once. The {@link MemoryNotificationInfo#getCount} method returns the numberof times that the memory usage has crossed the usage threshold at the point in time when the notification was constructed. It can be compared with the current usage threshold count returned by the {@link #getUsageThresholdCount} method to determine if such situation has occurred.

4. Collection Usage Threshold

The {@link MemoryPoolMXBean#isCollectionUsageThresholdSupported} method can be used to determine if this functionality is supported.

A Java virtual machine performs collection usage threshold checking on a memory pool basis. This checking is enabled if the collection usage threshold is set to a positive value. If the collection usage threshold is set to zero, this checking is disabled on this memory pool. Default value is zero. The Java virtual machine performs the collection usage threshold checking at garbage collection time.

Some garbage-collected memory pools may choose not to support the collection usage threshold. For example, a memory pool is only managed by a continuous concurrent garbage collector. Objects can be allocated in this memory pool by some thread while the unused objects are reclaimed by the concurrent garbage collector simultaneously. Unless there is a well-defined garbage collection time which is the best appropriate time to check the memory usage, the collection usage threshold should not be supported.

The collection usage threshold is designed for monitoring the memory usage after the Java virtual machine has expended effort in reclaiming memory space. The collection usage could also be monitored by the polling and threshold notification mechanism described above for the usage threshold in a similar fashion. @see JMX Specification. @see Ways to Access MXBeans @author Mandy Chung @version 1.21, 03/08/06 @since 1.5

  initialise()
  {
    try{
      List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
    
      MemoryPoolMXBean   pool_to_monitor = null;
      long        ptm_size    = 0;
      
      long  overall_max = 0;
      
      for ( MemoryPoolMXBean pool: pools ){
      
        long pool_max = pool.getUsage().getMax();
        
        if ( pool_max > 0 ){
          
          if ( pool.getType() == MemoryType.HEAP ){
          
            overall_max += pool_max;
          }
        }
        
        if ( pool.getType() == MemoryType.HEAP && pool.isCollectionUsageThresholdSupported()){
        
          long max = pool.getUsage().getMax();
          
          if ( max > ptm_size ){
            
            pool_to_monitor = pool;
            ptm_size    = max;
          }
        }
      }
      
      max_heap_mb = (overall_max+MB-1)/MB;


      if ( pool_to_monitor != null ){


        long max = pool_to_monitor.getUsage().getMax();
        
        long threshold = max*3/4;
        
        threshold = Math.min( threshold, 5*1024*1024 );
        
        MemoryMXBean mbean = ManagementFactory.getMemoryMXBean();


        NotificationEmitter emitter = (NotificationEmitter) mbean;


        
        emitter.addNotificationListener(
          new NotificationListener()
          {
            private long  last_mb_log = Long.MAX_VALUE;
            
            private boolean increase_tried;
            
            public void 
            handleNotification(
              Notification   notification, 
              Object       handback ) 
            {
              MemoryPoolMXBean pool = (MemoryPoolMXBean)handback;


              long used   = pool.getCollectionUsage().getUsed();
              long max   = pool.getUsage().getMax();
              
              long avail = max-used;
              
              if ( avail < 0 ){
                avail = 0;
              }
              
              long  mb = (avail+MB-1)/(MB);
              
              if ( mb <= 4 ){
                
                synchronized( this ){
                  
                  if ( mb >= last_mb_log ){
                    
                    return;
                  }
                  
                  last_mb_log = mb;
                }
                
                Runtime runtime = Runtime.getRuntime();
                
                Debug.out( "MemMon: notify triggered: pool=" + pool.getName() + 
                      ", used=" + used + 
                      ", max=" + max + 
                      ": runtime free=" + runtime.freeMemory() + ", tot=" + runtime.totalMemory() + ", max=" + runtime.maxMemory());


                 Logger.logTextResource(

         try {
            String notifType = notification.getType();
            if (!notifType.equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED))
               return;


            MemoryPoolMXBean pool = (MemoryPoolMXBean)handback;


            int numTries = 5;
            for (int i=0; i<numTries; i++) {
               // Memory is low! maxJvmMemory=8.323 MBytes, max for heap=7.340 MBytes, otherMem=983040, threshold reached=6.606 MBytes,
               // Runtime.totalMemory=8323072, Runtime.freeMemory=1461904, usedMem=6.861 MBytes
               if (log.isLoggable(Level.FINE))
                  log.fine(
                  "Memory is low! maxJvmMemory=" + Global.byteString(LowMemoryDetector.maxJvmMemory()) +
                  ", max for heap=" + Global.byteString(pool.getUsage().getMax()) +
                  ", otherMem=" + Global.byteString(LowMemoryDetector.maxJvmMemory() - pool.getUsage().getMax()) +  // 8.323-7.340=0.983
                  ", threshold reached=" + Global.byteString(pool.getUsageThreshold()) +
                  ", Runtime.totalMemory=" + Global.byteString(Runtime.getRuntime().totalMemory()) +
                  ", Runtime.freeMemory=" + Global.byteString(Runtime.getRuntime().freeMemory()) +
                  ", usedMem=" + Global.byteString(Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()));


               System.gc();
               try { Thread.sleep(1); } catch (Exception e) {}


               long usedMem = (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
               if (usedMem < pool.getUsageThreshold()) {
                  if (log.isLoggable(Level.FINE))
                     log.fine("Low memory: Nothing to do, the garbage collector has handled it usedMem=" + Global.byteString(usedMem) + " threshold=" + Global.byteString(pool.getUsageThreshold()));
                  return;  // Nothing to do, the garbage collector has handled it
               }
            }


            long usedMem = (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());


            //Memory is low! maxJvmMemory=8.323 MBytes, committed for heap=7.340 MBytes, max for heap=7.340 MBytes,
            //threshold reached=6.606 MBytes, currently used=7.595 MBytes, count=2.
            //Physical RAM size is 1.060 GBytes, this JVM may use max 8.323 MBytes and max 1024 file descriptors
            log.severe("Memory is low! maxJvmMemory=" + Global.byteString(LowMemoryDetector.maxJvmMemory()) +
               //", committed for heap=" + Global.byteString(pool.getUsage().getCommitted()) +
               ", max for heap=" + Global.byteString(pool.getUsage().getMax()) +
               ", threshold reached=" + Global.byteString(pool.getUsageThreshold()) +
               ", currently used=" + Global.byteString(usedMem) +
               ", count=" + pool.getUsageThresholdCount() +
               ". Physical RAM size is " + Global.byteString(Global.totalPhysicalMemorySize) + "," +
               " this JVM may use max " + Global.byteString(Global.heapMemoryUsage) +
               " and max " + Global.maxFileDescriptorCount + " file descriptors");
            if (this.exitOnThreshold) {
               System.gc();
               try { Thread.sleep(1); } catch (Exception e) {}
               System.gc();
               try { Thread.sleep(1); } catch (Exception e) {}
               usedMem = (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
               if (usedMem > pool.getUsageThreshold()) {
                  log.severe("Exiting now because of low memory (see '-xmlBlaster/jmx/exitOnMemoryThreshold true'");
                  System.exit(-9);
               }
               log.info("Garbage collected to usedMem=" + Global.byteString(usedMem) + ", we continue");
            }

    private boolean firstCollectionThreshExceededLogged = false;
    
    public SpillableMemoryManager() {
        ((NotificationEmitter)ManagementFactory.getMemoryMXBean()).addNotificationListener(this, null, null);
        List<MemoryPoolMXBean> mpbeans = ManagementFactory.getMemoryPoolMXBeans();
        MemoryPoolMXBean biggestHeap = null;
        long biggestSize = 0;
        for (MemoryPoolMXBean b: mpbeans) {
            log.debug("Found heap (" + b.getName() +
                ") of type " + b.getType());
            if (b.getType() == MemoryType.HEAP) {
                /* Here we are making the leap of faith that the biggest
                 * heap is the tenured heap
                 */
                long size = b.getUsage().getMax();
                if (size > biggestSize) {
                    biggestSize = size;
                    biggestHeap = b;
                }
            }
        }
        if (biggestHeap == null) {
            throw new RuntimeException("Couldn't find heap");
        }
        log.debug("Selected heap to monitor (" +
            biggestHeap.getName() + ")");
        
        // we want to set both collection and usage threshold alerts to be 
        // safe. In some local tests after a point only collection threshold
        // notifications were being sent though usage threshold notifications
        // were sent early on. So using both would ensure that
        // 1) we get notified early (though usage threshold exceeded notifications)
        // 2) we get notified always when threshold is exceeded (either usage or
        //    collection)
        
        /* We set the threshold to be 50% of tenured since that is where
         * the GC starts to dominate CPU time according to Sun doc */
        biggestHeap.setCollectionUsageThreshold((long)(biggestSize * collectionMemoryThresholdFraction));
        // we set a higher threshold for usage threshold exceeded notification
        // since this is more likely to be effective sooner and we do not
        // want to be spilling too soon
        biggestHeap.setUsageThreshold((long)(biggestSize * memoryThresholdFraction));
    }

        }


        for (ModelNode node : mps) {
            DescribedResource describedResource = basicResourceTest("memory-pool", node.asString());


            MemoryPoolMXBean mbean = mbeans.get(describedResource.resource.get("name").asString());
            Assert.assertNotNull(mbean);


            boolean usageSupported = describedResource.resource.get("usage-threshold-supported").asBoolean();
            Assert.assertEquals(mbean.isUsageThresholdSupported(), usageSupported);
            boolean collUsageSupported = describedResource.resource.get("collection-usage-threshold-supported").asBoolean();
            Assert.assertEquals(mbean.isCollectionUsageThresholdSupported(), collUsageSupported);


            ModelNode op = getOperation("reset-peak-usage", "memory-pool", node.asString());
            Assert.assertFalse(executeOp(op, false).isDefined());


            op = getOperation("write-attribute", "memory-pool", node.asString());
            op.get("name").set("usage-threshold");
            op.get("value").set(1024 * 100);
            ModelNode result = executeOp(op, !usageSupported);
            if (usageSupported) {
                Assert.assertEquals(1024 * 100, mbean.getUsageThreshold());
            }


            op = getOperation("write-attribute", "memory-pool", node.asString());
            op.get("name").set("collection-usage-threshold");
            op.get("value").set(1024 * 100);
            result = executeOp(op, !collUsageSupported);
            if (collUsageSupported) {
                Assert.assertEquals(1024 * 100, mbean.getCollectionUsageThreshold());
            }
        }
    }

    private static double collectionMemoryThresholdFraction = 0.5;
        
    public SpillableMemoryManager() {
        ((NotificationEmitter)ManagementFactory.getMemoryMXBean()).addNotificationListener(this, null, null);
        List<MemoryPoolMXBean> mpbeans = ManagementFactory.getMemoryPoolMXBeans();
        MemoryPoolMXBean biggestHeap = null;
        long biggestSize = 0;
        for (MemoryPoolMXBean b: mpbeans) {
            log.debug("Found heap (" + b.getName() +
                ") of type " + b.getType());
            if (b.getType() == MemoryType.HEAP) {
                /* Here we are making the leap of faith that the biggest
                 * heap is the tenured heap
                 */
                long size = b.getUsage().getMax();
                if (size > biggestSize) {
                    biggestSize = size;
                    biggestHeap = b;
                }
            }
        }
        if (biggestHeap == null) {
            throw new RuntimeException("Couldn't find heap");
        }
        log.debug("Selected heap to monitor (" +
            biggestHeap.getName() + ")");
        
        // we want to set both collection and usage threshold alerts to be 
        // safe. In some local tests after a point only collection threshold
        // notifications were being sent though usage threshold notifications
        // were sent early on. So using both would ensure that
        // 1) we get notified early (though usage threshold exceeded notifications)
        // 2) we get notified always when threshold is exceeded (either usage or
        //    collection)
        
        /* We set the threshold to be 50% of tenured since that is where
         * the GC starts to dominate CPU time according to Sun doc */
        biggestHeap.setCollectionUsageThreshold((long)(biggestSize * collectionMemoryThresholdFraction));
        // we set a higher threshold for usage threshold exceeded notification
        // since this is more likely to be effective sooner and we do not
        // want to be spilling too soon
        biggestHeap.setUsageThreshold((long)(biggestSize * memoryThresholdFraction));
    }

    private static double collectionMemoryThresholdFraction = 0.5;
        
    public SpillableMemoryManager() {
        ((NotificationEmitter)ManagementFactory.getMemoryMXBean()).addNotificationListener(this, null, null);
        List<MemoryPoolMXBean> mpbeans = ManagementFactory.getMemoryPoolMXBeans();
        MemoryPoolMXBean biggestHeap = null;
        long biggestSize = 0;
        for (MemoryPoolMXBean b: mpbeans) {
            log.debug("Found heap (" + b.getName() +
                ") of type " + b.getType());
            if (b.getType() == MemoryType.HEAP) {
                /* Here we are making the leap of faith that the biggest
                 * heap is the tenured heap
                 */
                long size = b.getUsage().getMax();
                if (size > biggestSize) {
                    biggestSize = size;
                    biggestHeap = b;
                }
            }
        }
        if (biggestHeap == null) {
            throw new RuntimeException("Couldn't find heap");
        }
        log.debug("Selected heap to monitor (" +
            biggestHeap.getName() + ")");
        
        // we want to set both collection and usage threshold alerts to be 
        // safe. In some local tests after a point only collection threshold
        // notifications were being sent though usage threshold notifications
        // were sent early on. So using both would ensure that
        // 1) we get notified early (though usage threshold exceeded notifications)
        // 2) we get notified always when threshold is exceeded (either usage or
        //    collection)
        
        /* We set the threshold to be 50% of tenured since that is where
         * the GC starts to dominate CPU time according to Sun doc */
        biggestHeap.setCollectionUsageThreshold((long)(biggestSize * collectionMemoryThresholdFraction));
        // we set a higher threshold for usage threshold exceeded notification
        // since this is more likely to be effective sooner and we do not
        // want to be spilling too soon
        biggestHeap.setUsageThreshold((long)(biggestSize * memoryThresholdFraction));
    }

Examples of java.lang.management.MemoryPoolMXBean

4. Collection Usage Threshold

Related Classes of java.lang.management.MemoryPoolMXBean