전형 적 인 자바 이벤트 모델

sun 의 코드 를 볼 때 많은 고전 이 실현 되 고 배 울 만 한 가치 가 있 습 니 다.다음은 sun 사건 처리 의 전형 적 인 실현 입 니 다.구체 적 으로 코드 를 보십시오.

public class MainLoop {
	
	private static MainLoop loop=null;
	
	private int pollRequests = 0;
	
	
    private MainLoop(){}

    public static MainLoop getInstance(){
		if(loop==null){
			loop=new MainLoop();
		}
		return loop;
	}
        //    
	public BaseEvent retrieveEvent() {
		return null;
	}
        //    
	private boolean checkEvents() {
		return false;
	}
	
	public synchronized void startPolling() {
		pollRequests++;
		PollingThread.pollingThreadResume();
	}

	public synchronized void stopPolling() {
		pollRequests--;
		if (pollRequests > 0) {
			return;
		}
		PollingThread.pollingThreadSuspend();
	}

	public void pollEvents() {
		while (checkEvents()) {
			BaseEvent event = retrieveEvent();
			if (event != null) {
				event.dispatch();
			}
		}
	}
}

      mainloop 주 제어 클래스 입 니 다.이 벤트 를 읽 으 려 면 startPolling 을 실행 하면 pollingThread 가 끊임없이 pollEvent 를 엽 니 다.
pollEvent 는 끊임없이 checkEvent 를 합 니 다.check 이 도착 하면 retrieveEvent 를 하고 받 은 이벤트 dispatch 를 합 니 다.
dispatch 이 벤트 는 이벤트 가 실 행 될 때 까지 이 벤트 를 대기 하 는 process 에 이 벤트 를 추가 합 니 다.이 벤트 를 읽 고 싶 지 않 을 때 바로 stopPolling.상황 에 따라
checkEvent 와 retrieveEvent 를 실현 하고 자신의 Event 계승 을 BaseEvent 에서 실현 합 니 다.
BaseEvent.java

public abstract class BaseEvent {
	 public void dispatch() {
	        Dispatcher.enqueue(this);
	    }

	    abstract public void process();
}

 PollingThread.java

public class PollingThread extends Thread {

	private static PollingThread instance = new PollingThread();

	private static boolean suspended = true;

	private final int POLL_INTERVAL = 1000;

	public PollingThread() {
	}

	public static void pollingThreadSuspend() {
		synchronized (instance) {
			suspended = true;
		}
	}

	public static void pollingThreadResume() {
		try {
			instance.start();
		} catch (IllegalThreadStateException e) {
		}
		synchronized (instance) {
			suspended = false;
			instance.notify();
		}
	}


	public void run() {
		MainLoop loop = MainLoop.getInstance();
		while (true) {
			try {
				synchronized (this) {
					if (suspended) {
						wait();
					}
				}
				loop.pollEvents();
				synchronized (this) {
					wait(POLL_INTERVAL);
				}
			} catch (InterruptedException e) {
				break;
			}
		}
	}
}

 Dispatcher.java

public class Dispatcher extends Thread {

	private static Dispatcher instance = new Dispatcher();

	private static Vector<BaseEvent> events = new Vector<BaseEvent>();

	public Dispatcher() {
	}


	public static void enqueue(BaseEvent event) {
		try {
			instance.start();
		} catch (IllegalThreadStateException e) {
		}
		synchronized (events) {
			events.addElement(event);
			events.notify();
		}
	}

	public void run() {
		while (true) {
			BaseEvent event = null;
			synchronized (events) {
				if (!events.isEmpty()) {
					event =events.firstElement();
					events.removeElementAt(0);
				} else {
					try {
						events.wait();
					} catch (InterruptedException e) {
						break;
					}
				}
			}
			if (event != null) {
				event.process();
			}
		}
	}
}