Java Observer与Observable源码解析

前言

Observer与Observable是JDK中内置的类型，是实现观察者模式重要的两个类，学习设计模式的时候只是简单的知晓这两个类中的一些方法使用，并不知道具体是咋样的，所以特地研究了一下其源码实现，如果需要知道怎么使用，请移步设计模式总结

Observer

先来看下源码

//此类位于util包中
 package java.util;

 public interface Observer {
 //参数o是被观察者的引用，arg是被观察者传来的信息
     void update(Observable o, Object arg);
 }

很简单的一个接口，仅提供一个update方法用于接收通知者的通知做出相应改变，其中第一个Observable类型的参数是被观察者的引用，当你需要与被观察者进行交互的时候，就需要这个引用了，另一个Object类型的参数是被观察者传递过来的信息，可以是实体，String，int，所以设置成了Object。

Observable

具有如下成员

public class Observable {
   //用来标志是否变化，默认无变化
    private boolean changed = false;
    //存储观察者对象
    private Vector<Observer> obs;
    //空构造方法
    public Observable(){};
    //设置变化，调用后changed为true
    protected synchronized void setChanged(){};
       //清除变化，调用后changed为false
    protected synchronized void clearChanged(){};
    //增加观察者，参数o为增加的对象
    public synchronized void addObserver(Observer o){};
    //删除观察者，参数o为被删除的对象
    public synchronized void deleteObserver(Observer o) {};
    //删除所有观察者
    public synchronized void deleteObservers(){};
    //是否变化
    public synchronized boolean hasChanged(){};
    //统计观察者数量然后返回
    public synchronized int countObservers(){};
    //通知所有观察者更新
    public void notifyObservers(){};
    //通知所有观察者更新，参数arg为通知内容
    public void notifyObservers(Object arg){};
}

源码如下

 package java.util;

  public class Observable {
      private boolean changed = false;　　//是否改变状态
      private Vector obs;　　　　//用来存储observer，用vector是因为其线程安全

      public Observable() {
          obs = new Vector();
     }

     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();
     }
 }

其他函数没有什么好说的容易理解，重点看看public void notifyObservers(Object arg){};

 public void notifyObservers(Object arg) {

         Object[] arrLocal;
       /*对change加同步锁，防止多线程下各线程对changed变量的读写操作不安全
       可能出现脏读因此产生重复update或者不能update的情况*/
         synchronized (this) {
         //如果没有变化，直接返回
             if (!changed)　　　　
                 return;
             arrLocal = obs.toArray();　　
             //重置变化
             clearChanged();　　　　
         }
         //循环通知更新
         for (int i = arrLocal.length-1; i>=0; i--)
             ((Observer)arrLocal[i]).update(this, arg);
     }

这段代码可以说设计的很巧妙了，首先就是同步锁，没有加在方法上，而是只加在了change这部分上，是因为只要不会引起变量状态的不一致性就行了，同时当同步块的代码执行完毕后，该线程可以先去执行耗时的for循环。避免了将循环放进同步方法中，如果并发量是十几二十的时候，就会特别耗时了。还有一个设计的很好的地方我觉得是Object[] arrLocal;源码中，没有选择直接操作obs，而是在同步方法中再保存了一次，这样更大程度上确保了观察者列表的线程安全，因为如果直接操作obs的话可能obs在其他线程中已经更新或者变化了。而复制一份就不一样了。这有点类似原型模式中的保护性克隆，为了防止这个只读对象被修改，通常可以通过返回给一个对象的拷贝的形式实现。

缺陷

使用Observable时需要使用继承，由于java的类单继承性，如果你的类已经继承了一个类，将不能继承Observable来实现观察者模式，并且由于setChanged和clearChanged方法都是protected的，所以你也不能通过组合来完成观察者模式，当然你如果自己写一个那另说了。