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

    private static SpillableMemoryManager manager;


    private 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 volatile SpillableMemoryManager manager;


    private SpillableMemoryManager() {
        ((NotificationEmitter)ManagementFactory.getMemoryMXBean()).addNotificationListener(this, null, null);
        List<MemoryPoolMXBean> mpbeans = ManagementFactory.getMemoryPoolMXBeans();
        MemoryPoolMXBean tenuredHeap = null;
        long tenuredHeapSize = 0;
        long totalSize = 0;
        for (MemoryPoolMXBean pool : mpbeans) {
            log.debug("Found heap (" + pool.getName() + ") of type " + pool.getType());
            if (pool.getType() == MemoryType.HEAP) {
                long size = pool.getUsage().getMax();
                totalSize += size;
                // CMS Old Gen or "tenured" is the only heap that supports
                // setting usage threshold.
                if (pool.isUsageThresholdSupported()) {
                    tenuredHeapSize = size;
                    tenuredHeap = pool;
                }
            }
        }
        extraGCSpillSizeThreshold  = (long) (totalSize * extraGCThresholdFraction);
        if (tenuredHeap == null) {
            throw new RuntimeException("Couldn't find heap");
        }
        log.debug("Selected heap to monitor (" +
            tenuredHeap.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 */
        tenuredHeap.setCollectionUsageThreshold((long)(tenuredHeapSize * 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
        tenuredHeap.setUsageThreshold((long)(tenuredHeapSize * memoryThresholdFraction));
    }

  
  
  
  public static MemoryPoolMXBean getPermGenSpaceBean() {
    java.util.List<MemoryPoolMXBean> manager = ManagementFactory.getMemoryPoolMXBeans();
    MemoryPoolMXBean bean;
    // PERM GEN
    Iterator<MemoryPoolMXBean> it = manager.iterator();
    while(it.hasNext()){
      bean = it.next();
      if("Perm Gen".equalsIgnoreCase(bean.getName()) || "CMS Perm Gen".equalsIgnoreCase(bean.getName())) {
        return bean;
      }
    }
    it = manager.iterator();
    while(it.hasNext()){
      bean = it.next();
      if(StringUtil.indexOfIgnoreCase(bean.getName(),"Perm Gen")!=-1 || StringUtil.indexOfIgnoreCase(bean.getName(),"PermGen")!=-1) {
        return bean;
      }
    }
    // take none-heap when only one
    it = manager.iterator();
    LinkedList<MemoryPoolMXBean> beans=new LinkedList<MemoryPoolMXBean>();
    while(it.hasNext()){
      bean = it.next();
      if(bean.getType().equals(MemoryType.NON_HEAP)) {
        beans.add(bean);
        return bean;
      }
    }
    if(beans.size()==1) return beans.getFirst();
    
    // Class Memory/ClassBlock Memory?
    it = manager.iterator();
    while(it.hasNext()){
      bean = it.next();
      if(StringUtil.indexOfIgnoreCase(bean.getName(),"Class Memory")!=-1) {
        return bean;
      }
    }

        KeyConstants._max,
        KeyConstants._init
    },0,"memory");
    
    int row=0;
    MemoryPoolMXBean bean;
    MemoryUsage usage;
    MemoryType _type;
    while(it.hasNext()){
      bean = it.next();
      usage = bean.getUsage();
      _type = bean.getType();
      if(type==MEMORY_TYPE_HEAP && _type!=MemoryType.HEAP)continue;
      if(type==MEMORY_TYPE_NON_HEAP && _type!=MemoryType.NON_HEAP)continue;
        
      row++;
      qry.addRow();
      qry.setAtEL(KeyConstants._name, row, bean.getName());
      qry.setAtEL(KeyConstants._type, row, _type.name());
      qry.setAtEL(KeyConstants._max, row, Caster.toDouble(usage.getMax()));
      qry.setAtEL(KeyConstants._used, row, Caster.toDouble(usage.getUsed()));
      qry.setAtEL(KeyConstants._init, row, Caster.toDouble(usage.getInit()));

    }
  };


  @Test
  public void explodePermGen() throws Exception {
    MemoryPoolMXBean permGenPool = null;
    for (MemoryPoolMXBean mp : ManagementFactory.getMemoryPoolMXBeans()) {
      if (mp.getName().contains("Perm Gen")) {
        permGenPool = mp;
        break;
      }
    }


    if (permGenPool == null) {
      // No permgen pool?
      Assume.assumeTrue(false);
    }


    // Just keep on loading classes until we explode.
    Random rnd = new Random(0xdeadbeef);
    int classes = 0;
    List<Class<?>> keep = new ArrayList<Class<?>>();
    while (true) {
      if ((classes++ % 1000) == 0) {
        System.out.println(permGenPool.getName() + " => " + permGenPool.getUsage());
      }


      // Prepare a new unique exception class with asm. Throw it.
      Class<?> clz = generateExceptionClass(rnd.nextLong());
      clz.newInstance();

Examples of java.lang.management.MemoryPoolMXBean

4. Collection Usage Threshold

Related Classes of java.lang.management.MemoryPoolMXBean