AsyncJobMonitor.java

/**
 * 
 */

import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class AsyncJobMonitor {

 private static final long INIT_TIME = System.currentTimeMillis();

 private Queue<Job> queue = new ConcurrentLinkedQueue<>();
 private Map<String, Long> endMap = new ConcurrentHashMap<>();

 public void start(Job job) {
 queue.add(job);
 }

 public void end(String id, long end) {
 endMap.put(id, end);
 cleanQueue();
 }

 private void cleanQueue() {
 while (!queue.isEmpty() && endMap.containsKey(queue.peek().id)) {
 Job curr = queue.poll();
 curr.end = endMap.get(curr.id);
 endMap.remove(curr.id);
 printJob(curr);
 }
 }

 private void printJob(Job job) {
 System.out.println(String.format("now: %s, job: %s, start: %s, end: %s",
 System.currentTimeMillis() - INIT_TIME,
 job.id,
 job.start - INIT_TIME,
 job.end - INIT_TIME));
 }

 static class Job {
 String id;
 long start;
 long end;
 Job(String id, long start) {
 this.id = id;
 this.start = start;
 }
 }

 public static void main(String[] args) {
 AsyncJobMonitor monitor = new AsyncJobMonitor();

 ExecutorService executorService = Executors.newFixedThreadPool(5);
 String[] ids = new String[]{"a", "b", "c", "d", "e"};
 long[] times = new long[]{5, 2, 5, 4, 1};
 for (int i=0; i<5; i++) {
 String id = ids[i];
 long time = times[i];
 executorService.execute(() -> {
 Job job = new Job(id, System.currentTimeMillis());
 monitor.start(job);
 try {
 TimeUnit.SECONDS.sleep(time);
 } catch (InterruptedException ex) {
 ex.printStackTrace();
 }
 monitor.end(id, System.currentTimeMillis());
 });
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException ex) {
 ex.printStackTrace();
 }
 }

 executorService.shutdown();
 }

}