java 线程意外中断重启处理办法(观察者模式)

java 线程意外中断重启处理办法 

使用观察者模式

具体代码

首先 线程需要继承Observable 

public class TestServer extends Observable implements Runnable {

	private static Logger logger = LoggerFactory.getLogger(TestServer.class);

	

	

	enum RunnableState {
		/**
		 * RUNNING：运行 ERROR：异常 DOWN：正常结束
		 */
		RUNNING, ERROR, DOWN
	}

	/**
	 * 发送通知
	 * 
	 * @param event
	 *            通知的内容
	 */
	private void notifyChange(final RunnableEvent event) {
		// 前面说过 JDK自带的 需要每次设置一次状态,代表当前内容更改了
		System.out.print("notifyChange");
		super.setChanged();
		super.notifyObservers(event);
	}

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

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

		RunnableState getState() {
			return state;
		}

		public Thread getThread() {
			return thread;
		}

		Throwable getCause() {
			return cause;
		}
	}

	@Override
	public void run() {
		try {
			while (true) {
				throw new RuntimeException("故意抛出错误");
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			notifyChange(new RunnableEvent(RunnableState.ERROR,
					Thread.currentThread(), e));
			System.out.print("抛出异常");

		}
	}

	

	public static void main(String args[]) {
		TestServer ts = new TestServer();
		ObserverListener listen = new ObserverListener();
		ts.addObserver(listen);	
	}
}

然后  写一个监听类ObserverListener   实现 Observer

public class ObserverListener implements Observer {
	/**
	 * 避免多线程锁竞争
	 */
	private static final Object LOCK = new Object();

	@Override
	public void update(Observable observable, Object runnableEvent) {
		synchronized (LOCK) {
			TestServer.RunnableEvent event = (TestServer.RunnableEvent) runnableEvent;
			if (event != null) {
				if (event.getCause() != null) {
					System.out.println("The Runnable ["
							+ event.getThread().getName()
							+ "] process failed and state is "
							+ event.getState().name());
					event.getCause().printStackTrace();
				} else {
					System.out.println("The Runnable ["
							+ event.getThread().getName()
							+ "] data changed and state is "
							+ event.getState().name());
				}
			}
		}
	}
}

需要注意的是  在New线程类TestServer的时候 

TestServer ts = new TestServer();
        ThreadListener listen = new ThreadListener();
        ts.addObserver(listen);    

必须加上  addObserver(listen)  这是TestServer  继承Observable而来的，如果不加上则监听不到

在监听类中，可以执行你想执行的结果，比如重启线程

       System.out.println("RunThread死机");

        TestServer ts = new TestServer();
        ts.addObserver(this);
        new Thread(ts, "tttt").start();

        System.out.println("RunThread重启");