深入了解LINUX下IO模式（一）——NIO及reactor模式

NIO中采用了当前比较热的reactor模式，废话不多说，上一个reactor的demo

 

Selector：

 

public class Selector
{
	private BlockingQueue<Event> queue = new LinkedBlockingQueue<>();
	
	private Object lock = new Object();

	public List<Event> select() {
		return select(0);
	}
	
	List<Event> select(long timeout) {
		if (timeout > 0 ) {
			if (queue.isEmpty()) {
				synchronized (lock)
				{
					if (queue.isEmpty()) {
						try {
							lock.wait(timeout);
						} catch (InterruptedException e) {
							
						}
					}
				}
			}
		}
		List<Event> list = new ArrayList<>();
		queue.drainTo(list);
		return list;
	}
	
	public void addEvent(Event event) {
		boolean success = queue.offer(event);
		if (success) {
			synchronized (lock)
			{
				lock.notify();
			}
		}
	}
}

 

 

Dispatcher:

 

public class Dispatcher
{

	private Map<EventType,EventHandler> eventHandlerMap = new HashMap<>();
	
	Selector selector;

	public Dispatcher(Selector selector)
	{
		super();
		this.selector = selector;
	}
	
	public void regisiterHandler(EventType eventType,EventHandler handler) {
		eventHandlerMap.put(eventType, handler);
	}
	
	public void removeHandler(EventType eventType) {
		eventHandlerMap.remove(eventType);
	}
	
	public void handle() {
		dispatch();
	}
	
	private void dispatch() {
		while (true) {
			List<Event> events = selector.select();
			
			for (Event event: events) {
				EventHandler eventHandler = eventHandlerMap.get(event.type);
				eventHandler.handle(event);
			}
		}
	}
}

 

 

Event:

 

public class Event
{

	public EventType type;

	public Event(EventType type)
	{
		super();
		this.type = type;
	}
	
}

 

 

EventType:

 

public enum EventType
{
	READ,WRITE,ACCEPT,QUIT
}

 

EventHandler:

 

public interface EventHandler
{

	void handle(Event event);
}

public class ReadEventHandler implements EventHandler
{

	@Override
	public void handle(Event event)
	{
		System.out.println("Read event handler");
	}

}

public class WriteEventHandler implements EventHandler
{

	@Override
	public void handle(Event event)
	{
		System.out.println("write event handler");
	}

}

 

 

Main:

public static void main(String[] args)
	{
		final Selector selector = new Selector();
		Dispatcher dispatcher = new Dispatcher(selector);
		dispatcher.regisiterHandler(EventType.READ, new ReadEventHandler());
		dispatcher.regisiterHandler(EventType.WRITE, new WriteEventHandler());
		for (int i = 0; i<10;i++) {
			final int j = i;
			Thread t = new Thread(new Runnable() {
				
				@Override
				public void run()
				{
					if (j%2==0) {
						selector.addEvent(new Event(EventType.READ));
					} else {
						selector.addEvent(new Event(EventType.WRITE));
					}
				}
			});
			t.start();
		}
		dispatcher.handle();
	}

 

 简单说明下，reactor必须有一个selector和dispatcher，

selector用于收集事件，dispacher用于将事件分派到不同的handler里去处理，

eventhandler由于具体业务处理的抽象

基于reactor的NIO及redis的单线程模式可见这样的一种编程模式效率并不会比纯异步的低。

 

普通异步处理：

 

reactor模式：