用观察者模式设计一个交通信号灯调度系统

这是本人在CSDN上的第一篇博客，写一篇有关于Java中设计模式，多线程调度的一个Demo吧,本人水平有限，望各位博友批评指正。此Demo实现了现实交通信号灯调度车辆通行的功能，为了方便大家理解，省去了黄色信号灯。

最近看了一些Java中的设计模式，比如最简单的单例模式，抽象工厂模式，观察者模式等。在学习了这些设计模式之后，我又对之前写过的一些程序做了改进，本文贴一个交通信号灯的系统，废话不多说，先看一种没有用观察者模式的实现（这种实现来源于传智播客的张孝祥老师的Java多线程课程中的一道面试题，有兴趣的博友可以查看点击打开链接）。

在附代码前先看一下需求吧：

Ø 异步随机生成按照各个路线行驶的车辆。

例如：

       由南向而来去往北向的车辆 ---- 直行车辆

       由西向而来去往南向的车辆 ---- 右转车辆

       由东向而来去往南向的车辆 ---- 左转车辆

       。。。

Ø 信号灯忽略黄灯，只考虑红灯和绿灯。

Ø 应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。

Ø 具体信号灯控制逻辑与现实生活中普通交通灯控制逻辑相同，不考虑特殊情况下的控制逻辑。

注：南北向车辆与东西向车辆交替放行，同方向等待车辆应先放行直行车辆而后放行左转车辆。

Ø 每辆车通过路口时间为1秒（提示：可通过线程Sleep的方式模拟）。

Ø 随机生成车辆时间间隔以及红绿灯交换时间间隔自定，可以设置。

Ø 不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

源代码：

Lamp.java

public enum Lamp {

	S2N("N2S", "S2W", false), S2W("N2E", "E2W", false), E2W("W2E", "E2S", false), E2S(
			"W2N", "S2N", false), N2S(null, null, false), N2E(null, null, false), W2E(
			null, null, false), W2N(null, null, false), S2E(null, null, true), E2N(
			null, null, true), N2W(null, null, true), W2S(null, null, true);

	private Lamp(String opposite, String next, boolean lighted) {
		this.opposite = opposite;
		this.next = next;
		this.lighted = lighted;
	}

	private String opposite;
	private String next;
	private boolean lighted;

	public boolean isLighted() {
		return lighted;
	}

	public void light() {
		this.lighted = true;
		if (opposite != null) {
			Lamp.valueOf(opposite).light();
		}
		System.out.println(name() + "方向的灯变绿了，下面将有6个方向的车辆通过！");
	}

	public Lamp blackOut() {
		/* 下面将当前路的灯变红 */
		this.lighted = false;
		if (opposite != null) {
			Lamp.valueOf(opposite).blackOut();
		}
		/* 下面将下面一条路的灯变绿 */
		Lamp nextLamp = null;
		if (next != null) {
			nextLamp = Lamp.valueOf(next);
			System.out.println(next + "方向的灯由红变绿了！");
			nextLamp.light();
		}
		return nextLamp;
	}
}

LampController.java

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class LampController {
	private Lamp currentLamp;

	public LampController(Lamp lamp) {
		currentLamp = lamp;
		currentLamp.light();
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				currentLamp = currentLamp.blackOut();
			}
		}, 10, 10, TimeUnit.SECONDS);
	}
}

Road.java

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Road {
	private String name;// 路名
	private List<String> vehicles = new ArrayList<String>();//车辆集合

	public Road(String name) {
		this.name = name;
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.schedule(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					try {
						Thread.sleep((new Random().nextInt(10) + 1) * 1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					vehicles.add("" + i);
				}
			}
		}, 0, TimeUnit.SECONDS);
		ScheduledExecutorService timer2 = Executors.newScheduledThreadPool(1);
		timer2.scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				if (vehicles.size() > 0) {
					boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
					if (lighted) {
						String current = vehicles.remove(0);
						System.out.println(Road.this.name + "路的当前第" + current
								+ "号正在通过路口！");
					}
				}
			}
		}, 1, 1, TimeUnit.SECONDS);
	}
}

Main.java

public class Main {
	public static void main(String[] args) {
		String[] directions = new String[] { "S2N", "S2W", "E2W", "E2S", "N2S",
				"N2E", "W2E", "W2N", "S2E", "E2N", "N2W", "W2S" };
		for (int i = 0; i < directions.length; i++) {
			new Road(directions[i]);
		}
		new LampController(Lamp.S2N);
	}
}

下面是使用观察者模式的方法：

Lamp.java

import java.util.Observable;

public class Lamp extends Observable {
	public Lamp(boolean lighted, String name) {
		this.lighted = lighted;
		this.name = name;
	}

	private Lamp opposite;
	private Lamp next;
	private boolean lighted;
	private String name;

	public String getName() {
		return name;
	}

	public void setNext(Lamp next) {
		this.next = next;
	}

	public void setOpposite(Lamp opposite) {
		this.opposite = opposite;
	}

	public boolean isLighted() {
		return lighted;
	}

	public void light() {
		this.lighted = true;
		System.out.println(this.name + "方向的灯变绿了！");
		if (opposite != null) {
			opposite.light();
		}
		// System.out.println(name+"方向的灯正在发送通知.....");
		// 下面两行通知观察者，此方向的路灯已变绿
		setChanged();
		notifyObservers(Boolean.TRUE);
	}

	public Lamp blackOut() {
		/* 下面将当前路的灯变红 */
		this.lighted = false;
		System.out.println(name + "方向的灯将要变红了！");
		if (opposite != null) {
			opposite.blackOut();
		}
		// 下面两行通知观察者，此方向的路灯已变红
		setChanged();
		notifyObservers(Boolean.FALSE);

		/* 下面将下面一条路的灯变绿 */
		Lamp nextLamp = null;
		if (next != null) {
			nextLamp = next;
			nextLamp.light();
		}
		return nextLamp;
	}
}

LampController.java

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class LampController {
	private Lamp currentLamp;

	public LampController() {
		Lamp S2N = new Lamp(false, "S2N");
		Lamp S2W = new Lamp(false, "S2W");
		Lamp E2W = new Lamp(false, "E2W");
		Lamp E2S = new Lamp(false, "E2S");
		Lamp N2S = new Lamp(false, "N2S");
		Lamp N2E = new Lamp(false, "N2E");
		Lamp W2E = new Lamp(false, "W2E");
		Lamp W2N = new Lamp(false, "W2N");
		Lamp S2E = new Lamp(true, "S2E");
		Lamp E2N = new Lamp(true, "E2N");
		Lamp N2W = new Lamp(true, "N2W");
		Lamp W2S = new Lamp(true, "W2S");
		S2N.setNext(S2W);
		S2W.setNext(E2W);
		E2W.setNext(E2S);
		E2S.setNext(S2N);

		S2N.setOpposite(N2S);
		S2W.setOpposite(N2E);
		E2W.setOpposite(W2E);
		E2S.setOpposite(W2N);
		Lamp[] lamps = new Lamp[] { S2N, S2W, E2W, E2S, N2S, N2E, W2E, W2N,
				S2E, E2N, N2W, W2S };
		for (int i = 0; i < lamps.length; i++) {
			new Road(lamps[i]);
			if (lamps[i].isLighted()) {
				lamps[i].light();
			}
		}
		currentLamp = S2N;
		currentLamp.light();
	}

	public void start() {
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				currentLamp = currentLamp.blackOut();
			}
		}, 10, 10, TimeUnit.SECONDS);
	}
}

Road.java

import java.util.LinkedList;
import java.util.Observable;
import java.util.Observer;
import java.util.Queue;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Road implements Observer {
	private String name;// 路名
	private Queue<String> vehicles = new LinkedList<String>();// 车辆集合
	private Timer timer2 = null;

	public Road(Lamp lamp) {
		lamp.addObserver(this);// 注册一个观察者
		this.name = lamp.getName();
		ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
		timer.schedule(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					try {
						Thread.sleep((new Random().nextInt(10) + 1) * 1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					vehicles.offer("" + i);
				}
			}
		}, 0, TimeUnit.SECONDS);
	}

	@Override
	public void update(Observable o, Object arg) {
		if (arg == Boolean.TRUE) {// 绿灯亮了
			System.out.println(name + "方向已经开始放行车辆通过！");
			timer2 = new Timer();
			timer2.schedule(new TimerTask() {
				@Override
				public void run() {
					if (vehicles.size() > 0) {
						String current = vehicles.poll();
						System.out.println(Road.this.name + "路的当前第" + current
								+ "号正在通过路口！");
					}
				}
			}, 1000, 1000);
		} else {// 红灯亮了
			timer2.cancel();
			System.out.println(name + "方向已停止车辆通行！");
		}
	}
}

Main.java

public class Main {

	public static void main(String[] args) {
		new LampController().start();
	}
}