How to use

java.util.concurrent.ExecutorService

constructor

 ThreadPoolExecutor pool = new ThreadPoolExecutor(...);
ExecutorService svc = new ControlledExecutorService(pool);
server.setThreadPool(new org.eclipse.jetty.util.thread.ExecutorThreadPool(svc));

 ExecutorService es = Executors.new.....
es.submit(new Runnable() {
  public void run() {
    // a task you want to pass to another thread
  }
});

 ExecutorService executor = new FixedThreadPool(100); //pool of 100 threads

...

Runnable r = new Runnable() {

  public void run() {
    try {
      System.out.println(cmd);
      Process process = Runtime.getRuntime().exec(cmd);
    } catch (IOException e) {
      e.printStackTrace();
    }  
  }
}

executor.submit(r);

 private static final int procs = Runtime.getRuntime().availableProcessors();
private final ExecutorService es = new Executors.newFixedThreadPool(procs);

int tasks = ....
int blockSize = (tasks + procss -1) / procs;
List<Future<Results>> futures = new ArrayList<>();

for(int i = 0; i < procs; i++) {
  int start = i * blockSize;
  int end = Math.min(tasks, (i + 1) * blockSize);
  futures.add(es.submit(new Task(start, end));
}

for(Future<Result> future: futures) {
  Result result = future.get();
  // check/accumulate result.
}

 ExecutorService executorService = new ThreadPoolExecutorService(...);
executorService.submit(new A(200));
executorService.submit(new A(100));
executorService.submit(new A(500));

executorService.shutdown();
executorService.awaitTermination(/* some timeout */);

System.out.println("Main Thread's rest of the code");

 public class ReportThread extends Thread {
 final int delay;
 boolean finished;

 ReportThread() { finished = false; }
 void done() { finished = true; }

 public void run() {
  while (!finished) {    
   Thread.sleep(delay);
   System.out.println("Computing long task..");
  }
 }
}

ReportThread report = new ReportThread(1000);
report.start();
ExecutorService service = new ExecutorService();
Future<T> future = service.submit(new Future<T>(new Callable<T>() {
 public T call() {
  // long task implementation
 })
);
T result = future.get();
report.done();

 public static void main(String[] args) throws InterruptedException {
  ExecutorService service = new TimeoutThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, 
      new LinkedBlockingQueue<Runnable>(), 10, TimeUnit.MINUTES);
  //ExecutorService service = Executors.newFixedThreadPool(1);
  try {
    final AtomicInteger counter = new AtomicInteger();
    for (long i = 0; i < 10000000; i++) {
      service.submit(new Runnable() {
        @Override
        public void run() {
          counter.incrementAndGet();
        }
      });
      if (i % 10000 == 0) {
        System.out.println(i + "/" + counter.get());
        while (i > counter.get()) {
          Thread.sleep(10);
        }
      }
    }
  } finally {
    service.shutdown();
  }
}

ExecutorService timedExecutor = new TimedExecutorService(numThreads, timeout, TimeUnit.SECONDS);
timedExecutor.execute(abcdRunnable);
timedExecutor.execute(xyzwRunnable);