前言
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的,所以你也不能通过组合来完成观察者模式,当然你如果自己写一个那另说了。