java 高性能Server —— Reactor模型单线程版

NIO模型

NIO模型示例如下：

• Acceptor注册Selector，监听accept事件
• 当客户端连接后，触发accept事件
• 服务器构建对应的Channel，并在其上注册Selector，监听读写事件
• 当发生读写事件后，进行相应的读写处理

NIO优缺点

• 优点
  • 性能瓶颈高
• 缺点
  • 模型复杂
  • 编码复杂
  • 需处理半包问题

NIO的优缺点和BIO就完全相反了!性能高，不用一个连接就建一个线程，可以一个线程处理所有的连接！相应的，编码就复杂很多，从上面的代码就可以明显体会到了。还有一个问题，由于是非阻塞的，应用无法知道什么时候消息读完了，就存在了半包问题！

半包问题

简单看一下下面的图就能理解半包问题了！

我们知道TCP/IP在发送消息的时候，可能会拆包(如上图1)！这就导致接收端无法知道什么时候收到的数据是一个完整的数据。例如:发送端分别发送了ABC,DEF,GHI三条信息，发送时被拆成了AB,CDRFG,H,I这四个包进行发送，接受端如何将其进行还原呢？在BIO模型中，当读不到数据后会阻塞，而NIO中不会!所以需要自行进行处理!例如，以换行符作为判断依据，或者定长消息发生，或者自定义协议！

NIO虽然性能高，但是编码复杂，且需要处理半包问题！为了方便的进行NIO开发，就有了Reactor模型!

Reactor模型

Reactor中的组件

• Reactor：负责响应事件，将事件分发给绑定了该事件的Handler处理；
• Handler：事件处理器，绑定了某类事件，负责执行对应事件的Task对事件进行处理；
• Acceptor：Handler的一种，绑定了ACCEPT事件，当客户端发起connect请求时，Reactor会将accept事件分发给Acceptor处理。

对应上面的NIO代码来看:

• Reactor：相当于有分发功能的Selector
• Acceptor：NIO中建立连接的那个判断分支
• Handler：消息读写处理等操作类

代码实现

服务端 Reactor.java

package com.test1;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Reactor implements Runnable {

	private ServerSocketChannel serverSocketChannel = null;

	private Selector selector = null;

	public Reactor() {
		try {
			selector = Selector.open();
			serverSocketChannel = ServerSocketChannel.open();
			serverSocketChannel.configureBlocking(false);
			serverSocketChannel.socket().bind(new InetSocketAddress(8888));
			SelectionKey selectionKey = serverSocketChannel.register(selector,
					SelectionKey.OP_ACCEPT);
			selectionKey.attach(new Acceptor());
			System.out.println("服务器启动正常!");
		} catch (IOException e) {
			System.out.println("启动服务器时出现异常!");
			e.printStackTrace();
		}
	}

	public void run() {
		while (true) {
			try {
				selector.select();

				Iterator<SelectionKey> iter = selector.selectedKeys()
						.iterator();
				while (iter.hasNext()) {
					SelectionKey selectionKey = iter.next();
					dispatch((Runnable) selectionKey.attachment());
					iter.remove();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public void dispatch(Runnable runnable) {
		if (runnable != null) {
			runnable.run();
		}
	}

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

	class Acceptor implements Runnable {
		public void run() {
			try {
				SocketChannel socketChannel = serverSocketChannel.accept();
				if (socketChannel != null) {
					System.out.println("接收到来自客户端（"
							+ socketChannel.socket().getInetAddress()
									.getHostAddress() + "）的连接");
					new Handler(selector, socketChannel);
				}

			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

class Handler implements Runnable {

	private static final int READ_STATUS = 1;

	private static final int WRITE_STATUS = 2;

	private SocketChannel socketChannel;

	private SelectionKey selectionKey;

	private int status = READ_STATUS;

	public Handler(Selector selector, SocketChannel socketChannel) {
		this.socketChannel = socketChannel;
		try {
			socketChannel.configureBlocking(false);
			selectionKey = socketChannel.register(selector, 0);
			selectionKey.interestOps(SelectionKey.OP_READ);
			selectionKey.attach(this);
			selector.wakeup();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void run() {
		try {
			if (status == READ_STATUS) {
				read();
				selectionKey.interestOps(SelectionKey.OP_WRITE);
				status = WRITE_STATUS;
			} else if (status == WRITE_STATUS) {
				process();
				selectionKey.cancel();
				System.out.println("服务器发送消息成功!");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void read() throws IOException {
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		socketChannel.read(buffer);
		System.out.println("接收到来自客户端（"
				+ socketChannel.socket().getInetAddress().getHostAddress()
				+ "）的消息：" + new String(buffer.array()));
	}

	public void process() throws IOException {
		String content = "Hello World!";
		ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
		socketChannel.write(buffer);
	}
}

客户端 Client.java

package com.test1;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class Client {

	ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
	ByteBuffer readBuffer = ByteBuffer.allocate(1024);

	public void start() throws IOException {
		// 打开socket通道
		SocketChannel sc = SocketChannel.open();
		// 设置为非阻塞
		sc.configureBlocking(false);
		// 连接服务器地址和端口
		//sc.connect(new InetSocketAddress("localhost", 8001));
		sc.connect(new InetSocketAddress("localhost", 8888));
		// 打开选择器
		Selector selector = Selector.open();
		// 注册连接服务器socket的动作
		sc.register(selector, SelectionKey.OP_CONNECT);

		Scanner scanner = new Scanner(System.in);
		while (true) {
			// 选择一组键，其相应的通道已为 I/O 操作准备就绪。
			// 此方法执行处于阻塞模式的选择操作。
			selector.select();
			// 返回此选择器的已选择键集。
			Set<SelectionKey> keys = selector.selectedKeys();
			System.out.println("keys=" + keys.size());
			Iterator<SelectionKey> keyIterator = keys.iterator();
			while (keyIterator.hasNext()) {
				SelectionKey key = keyIterator.next();
				keyIterator.remove();
				// 判断此通道上是否正在进行连接操作。
				if (key.isConnectable()) {
					sc.finishConnect();
					sc.register(selector, SelectionKey.OP_WRITE);
					System.out.println("server connected...");
					break;
				} else if (key.isWritable()) { // 写数据
					System.out.print("please input message:");
					String message = scanner.nextLine();
					// ByteBuffer writeBuffer =
					// ByteBuffer.wrap(message.getBytes());
					writeBuffer.clear();
					writeBuffer.put(message.getBytes());
					// 将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
					writeBuffer.flip();
					sc.write(writeBuffer);

					// 注册写操作,每个chanel只能注册一个操作，最后注册的一个生效
					// 如果你对不止一种事件感兴趣，那么可以用“位或”操作符将常量连接起来
					// int interestSet = SelectionKey.OP_READ |
					// SelectionKey.OP_WRITE;
					// 使用interest集合
					sc.register(selector, SelectionKey.OP_READ);
					sc.register(selector, SelectionKey.OP_WRITE);
					sc.register(selector, SelectionKey.OP_READ);

				} else if (key.isReadable()) {// 读取数据
					System.out.print("receive message:");
					SocketChannel client = (SocketChannel) key.channel();
					// 将缓冲区清空以备下次读取
					readBuffer.clear();
					int num = client.read(readBuffer);
					System.out.println(new String(readBuffer.array(), 0, num));
					// 注册读操作，下一次读取
					sc.register(selector, SelectionKey.OP_WRITE);
				}
			}
		}
	}

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