基于观察者模式，写的多线程监听

主要用于并发不高的多线程监听

public interface LifeCycleListener {

    void onEvent(ObservableRunnable.RunnableEvent event);
}

public abstract class ObservableRunnable implements Runnable{

    final protected LifeCycleListener listener;

    public ObservableRunnable(LifeCycleListener lifeCycleListener){
        this.listener = lifeCycleListener;
    }

    protected void notifyChange(final RunnableEvent event){
        listener.onEvent(event);
    }

    public enum RunnableState{
        RUNNING , ERROR , DONE
    }

    public static class RunnableEvent{
        private final RunnableState state;
        private final Thread thread;
        private final Throwable throwable;

        public RunnableEvent(RunnableState state, Thread thread, Throwable throwable) {
            this.state = state;
            this.thread = thread;
            this.throwable = throwable;
        }

        public RunnableState getState() {
            return state;
        }

        public Thread getThread() {
            return thread;
        }

        public Throwable getThrowable() {
            return throwable;
        }
    }
}

public class ThreadLifeCycleObserver implements LifeCycleListener {

    private  final Object LOCK = new Object();

    public void concurrentQuery(List<String> ids){
        if(ids == null || ids.isEmpty()){
            return;
        }

        ids.stream().forEach(id -> new Thread(new ObservableRunnable(this) {
            @Override
            public void run() {
                try {
                    notifyChange(new RunnableEvent(RunnableState.RUNNING,Thread.currentThread(),null));
                    System.out.println("query for the id" + id);
                    Thread.sleep(1000);
                    notifyChange(new RunnableEvent(RunnableState.DONE,Thread.currentThread(),null));
                } catch (InterruptedException e) {
                    notifyChange(new RunnableEvent(RunnableState.ERROR,Thread.currentThread(),null));
                }
            }
        }).start());

    }

    @Override
    public void onEvent(ObservableRunnable.RunnableEvent event) {

        synchronized (LOCK){
            System.out.println(event.getThread().getName() + "===" + event.getState());
            if(event.getThrowable() != null){
                // 仅仅打印
                event.getThrowable().getStackTrace();
            }
        }
    }
}

main 方法

  public static void main(String[] args) {
        new ThreadLifeCycleObserver().concurrentQuery(Arrays.asList("1","2"));
    }