Java中的Observable和Observer源码分析

先贴下源码Observable（顺便做了些简单注释，详细的英文注释大家可以去看源码，我这就没贴了）：

package java.util;


public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();//Vector是ArrayList的线程安全版本
    }

    //不能重复添加
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    //方法的重载

    public void notifyObservers() {
        notifyObservers(null);
    }

    //这部分下面要重点讲下
    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {

            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    //下面没什么好说的

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}  

　　再看下Observer：

package java.util;


public interface Observer {

    void update(Observable o, Object arg);

}  

　　知道观察者模式的话，上面的代码扫一眼就差不多懂了。
　　
　　下面我们来思考几个问题。
　　我们可以看到Observable的方法都加上了synchronized来进行同步，除了notifyObservers之外。我们来先看下源码里这部分代码的作者怎么说的：

/* We don't want the Observer doing callbacks into
* arbitrary code while holding its own Monitor.
* The code where we extract each Observable from
* the Vector and store the state of the Observer
* needs synchronization, but notifying observers
* does not (should not).  The worst result of any
* potential race-condition here is that:
* 1) a newly-added Observer will miss a
*   notification in progress
* 2) a recently unregistered Observer will be
*   wrongly notified when it doesn't care
*/   

　　大概就说了下没这样做，也不应该这样做，还说了下这样可能会导致的两个最坏结果，并没有说明具体的原因。（PS：上面的extract each Observable from the Vector难道不应该是extract each Observer from the Vector。。。还是我的理解有问题。。。）
　　我个人觉得主要的原因应该是如果这个方法加上了synchronized，那么在多线程环境下，如果某一个线程调用了Observable的notifyObservers，那么其他线程就会被阻塞，而notifyObservers这个方法中有个遍历的update操作，这个过程可能会花费较长时间，这样会对效率有较大的影响。
　　
　　我们再来看下notifyObservers方法中的同步块里做了什么，另外两句不说，主要看下下面这句：

arrLocal = obs.toArray();  

　　对Observers做了个缓存，为什么要做这个缓存？
　　我们考虑下如果不做这个缓存会怎么样，当某个线程遍历到一半时，另一个线程删除了它将要遍历的元素，那就会发生NullPointerException了。而且这样缓存后可以提供更好的并发性，因为多个线程可以同时迭代列表。
　　
　　不过做了这个缓存后就可能会出现上面代码作者所说的两个问题：
　　一方面不该通知的被通知了，比如一个线程已经把某个Observer删除了，表示它不需要被通知了，另一个线程还是会通知它。
　　另一方面是该通知的没被通知到，比如如果一个线程加了个Observer，希望它会被通知到，但另一个线程在遍历进行update时，不会通知到它，这个Observer就会错过这次通知。
　　
　　下面是用Observer和Observable写的一个简单的观察者模式：

package com.company;

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

public class Test5 {

    public static void main(String[] args) {
        new Test5().Method();
    }

    public void Method() {
        MyObservable myObservable = new MyObservable();
        MyObserver myObserver = new MyObserver();
        MyObserver myObserver1 = new MyObserver();
        MyObserver myObserver2 = new MyObserver();
        myObservable.addObserver(myObserver);
        myObservable.addObserver(myObserver1);
        myObservable.addObserver(myObserver2);
        myObservable.publishChange();
    }


    class MyObserver implements Observer {
        @Override
        public void update(Observable o, Object arg) {
            System.out.println(this + "说：" + o + "有变化了。。。");
        }
    }

    class MyObservable extends Observable {
        public void publishChange() {
            setChanged();
            notifyObservers();
        }
    }

}  

　　结果如下：

com.company.Test5$MyObserver@61bbe9ba说：com.company.Test5$MyObservable@610455d6有变化了。。。
com.company.Test5$MyObserver@511d50c0说：com.company.Test5$MyObservable@610455d6有变化了。。。
com.company.Test5$MyObserver@60e53b93说：com.company.Test5$MyObservable@610455d6有变化了。。。