描述一个场景
我们六个人坐在会议室，分别是俊哥，鹏哥，伟哥，瑞哥，玮姐和我。鹏哥老司机在开车，伟哥在看球，突然玮姐发现罗总来了，赶紧说了一句：罗总来了！这时候，鹏哥停车，好好写代码；伟哥关掉视频，也好好做项目。
UML类图
观察者设计模式.png
注意线程安全
Client类
public interface Client {
void change();
}
Observable类
public class Subject {
private List<SynchronizeObserver> list = new ArrayList<SynchronizeObserver>();
public synchronized void add(SynchronizeObserver observers) {
list.add(observers);
System.out.println("添加了一个观察者");
}
public synchronized void delete(SynchronizeObserver observers) {
list.remove(observers);
}
public void notifyAllObservers(final String state) {
ExecutorService ex = Executors.newFixedThreadPool(1000);
for ( final SynchronizeObserver observers : list) {
observers.runUpdate(ex);
}
}
}
WeiJie类
public class WeiJie extends Subject implements Client {
private String state;
public void change() {
this.state = state;
this.notifyAllObservers(state);
}
}
SynchronizeObserver类
public abstract class SynchronizeObserver implements Observer {
public abstract void update(Observable o, Object arg);
public final void runUpdate(ExecutorService ex){
ex.execute(new Runnable() {
public void run() {
update(null, "");
}
});
}
}
用到线程池，这样写使子类实现update()方法时一定是在子线程中进行的。
如果是在for循环中new Thread，那么每次循环都有创建线程的时间，比较耗时，所以把创建线程的工作移到了方法内部进行。
PengGe类
public class PengGe extends SynchronizeObserver {
@Override
public void update(Observable o, Object arg) {
System.out.println("停车吧 老司机");
}
}
WeiGe类
public class WeiGe extends SynchronizeObserver {
@Override
public void update(Observable o, Object arg) {
System.out.println("今天驾校不上课");
}
}
测试类
public class Test {
public static void main(String[] args) {
WeiJie weiJie = new WeiJie();
SynchronizeObserver pengGe = new PengGe();
SynchronizeObserver sangWei = new SangWei();
weiJie.add(pengGe);
weiJie.add(sangWei);
weiJie.change();
}
}
