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() 才会开一个子线程。