主要用于并发不高的多线程监听
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"));
}