java的观察者模式（有点监听器的感觉），Thread和Runnable的区别

这里面有两个概念：

Obserable 为被观察的人，

Observer  为观察的人，当被观察的人做了特定的工作之后，观察者就激活了。

直接上代码：被观察者

package com.flyread.thread;

import java.util.Iterator;
import java.util.Observable;
import java.util.Queue;

/**
* FlyLoggerThread
* Created by sff on 2017/5/6.
*/
public class FlyLoggerThread<T extends Task> extends Observable implements Runnable {

/** 任务队列 */
private Queue<T> tasks;
/** 是将线程挂起和激活用的 */
private Object object;
/** 判断线程是不是被锁住，用于jvm异常关闭 */
private Boolean isLocked;

private int times = 0;
public void doBusiness(){
//出现异常时，通知一个别的线程。
if(true){
super.setChanged();
}
//        notifyObservers(this);
notifyObservers();
}

public FlyLoggerThread(){
super();
object = 1;
isLocked = false;
//tasks初始化
}

@Override
public void run(){
// 如果是Socket线程
/**
* 开启线程
*/
// 如果是File、Console线程则不需要在while死循环前写前续代码
// 在这里到底是文件操作还是Socket的连接的前续工作不能写，所以这个不适合将SocketThread、FileThread、ConsoleThread整合。
// 但是可以将FileThread、ConsoleThread整合起来，因为他们不需要前续操作。
try{
//           while(true){
//               if(tasks.size() > 0){
//                   Iterator iterator = tasks.iterator();
//                   while(iterator.hasNext()){
//                       T t = (T) iterator.next();
//                       t.doTask();
//                       popTask();
//                   }
//               } else{
//
//               }
//           }
times ++;
System.out.println(times);
Thread.sleep(1000);
int b = Integer.parseInt("aa");
} catch (Exception e) {
// 被中断。应该停止
e.printStackTrace();
doBusiness();
}
}

public void threadWait(){
try{
object.wait();
} catch (InterruptedException e){

}
}

public void threadNotify(){
object.notify();
}

public void pushTask(T task){
if(!isLocked){
synchronized (tasks){
tasks.add(task);
}
}
}

public void popTask(){
synchronized (tasks){
tasks.remove();
}
}
}

观察者：

package com.flyread.thread;

import java.util.Observable;
import java.util.Observer;

/**
* FlyLoggerThreadListener
* Created by sff on 2017/5/6.
*/
public class FlyLoggerThreadListener implements Observer {
@Override
public void update(Observable o, Object arg) {
//        Object b = arg;
FlyLoggerThread thread = (FlyLoggerThread) o;
System.out.println("RunThread死机");
//从线程池中判断是哪个有问题
new Thread(thread).start();
System.out.println("RunThread重启");
}

}

运行代码：

package com.flyread.thread;

/**
* 测试Observable
* Created by sff on 2017/5/6.
*/
public class ListenerTest {
public static void main(String[] args){
FlyLoggerThread<Task> t = new FlyLoggerThread<>();
FlyLoggerThreadListener listener = new FlyLoggerThreadListener();
t.addObserver(listener);
new Thread(t).start();
}
}

运行结果：



参考：

Java线程监听，意外退出线程后自动重启

Runnable和Thread的区别。

Runnable是一个接口，只有一个run方法。而Thread是一个类，它实现了Runnable。Thread.run()方法不会开一个子线程的，Thread.start()才会开一个子线程。Runnable.run()也不会开一个子线程的，new Thread(Runnable).start() 才会开一个子线程。