Java executor that configures thread pool based on CPU and RAM usage

One approach would be to use a ThreadPoolExecutor with a core size of 1, an initial maximum pool size of 4, then dynamically adjust the maximum pool size based on memory and CPU usage.

The big problem imho is how to measure memory usage and cpu load. Memory usage is simple enough:

public double memUsageRatio() {
  Runtime r = Runtime.getRuntime();
  return (double) (r.totalMemory() - r.freeMemory()) / r.maxMemory();
}

      

        
        
        
      

    

For CPU usage, this can be more problematic, depending on the platform you are running on. On Linux, you can use:

ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage();

      

        
        
        
      

    

This returns the average system load over the last minute. Unfortunately on Windows this method always returns -1. Previously, I replaced it with an approximation of the average system load for a given interval, calculating the sum of the processor times for all threads, divided by the sum of all elapsed times for all processors. This is only an approximation, but it works very well in most cases:

import java.lang.management.*;

public class CPUUsageCollector implements Runnable {
  private final static long INTERVAL = 1000L; // polling interval in ms
  private long totalCpuTime = 0L; // total CPU time in millis
  private double load = 0d; // average load over the interval
  ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
  boolean stopped = false;

  @Override
  public void run() {
    try {
      while (!isStopped()) {
        long start = System.currentTimeMillis();
        long[] ids = threadMXBean.getAllThreadIds();
        long time = 0L;
        for (long id: ids) {
          long l = threadMXBean.getThreadCpuTime(id);
          if (l >= 0L) time += l;
        }
        long newCpuTime = time / 1000000L;
        synchronized(this) {
          long oldCpuTime = totalCpuTime;
          totalCpuTime = newCpuTime;
          // load = CPU time difference / sum of elapsed time for all CPUs
          load = (double) (newCpuTime - oldCpuTime) / 
           (double) (INTERVAL * Runtime.getRuntime().availableProcessors());
        }
        long sleepTime = INTERVAL - (System.currentTimeMillis() - start);
        goToSleep(sleepTime <= 0L ? INTERVAL : sleepTime);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public synchronized double getLoad() {
    return load;
  }

  public synchronized void goToSleep(final long time) {
    try {
      wait(time);
    } catch(InterruptedException e) {
      e.printStackTrace();
    }
  }

  public synchronized boolean isStopped() {
    return stopped;
  }

  public synchronized void setStopped(final boolean stopped) {
    this.stopped = stopped;
  }
}