网络编程基础(3) : IO多路复用(单线程)

1. 简介

IO多路复用(multiplexing)属于同步IO网络模型

是以Reactor模式实现

常见的IO多路复用应用有：select、poll、epoll

有关于select的应用方式，请参阅[C语言] 基于Linux的一对一Socket简易聊天程序实例

本篇文章采用Java的NIO框架来实现单线程的IO多路复用

2. Reactor模式的组成角色

1. Reactor：负责派发IO事件给对应的角色处理。为了监听IO事件，select必须实现在Reactor中。

2. Acceptor：负责接受client的连线，然后给client绑定一个Handler并注册IO事件到Reactor上监听。

3. Handler：负责处理与client交互的事件或行为。通常因为Handler要处理与所对应client交互的多个事件或行为，为了简化设计，会以状态模式来实现Handler。

3. 代码实现

[TCPReactor.java]

// Reactor線程
package server;

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

public class TCPReactor implements Runnable {

	private final ServerSocketChannel ssc;
	private final Selector selector;

	public TCPReactor(int port) throws IOException {
		selector = Selector.open();
		ssc = ServerSocketChannel.open();
		InetSocketAddress addr = new InetSocketAddress(port);
		ssc.socket().bind(addr); // 在ServerSocketChannel綁定監聽端口
		ssc.configureBlocking(false); // 設置ServerSocketChannel為非阻塞
		SelectionKey sk = ssc.register(selector, SelectionKey.OP_ACCEPT); // ServerSocketChannel向selector註冊一個OP_ACCEPT事件，然後返回該通道的key
		sk.attach(new Acceptor(selector, ssc)); // 給定key一個附加的Acceptor對象
	}

	@Override
	public void run() {
		while (!Thread.interrupted()) { // 在線程被中斷前持續運行
			System.out.println("Waiting for new event on port: " + ssc.socket().getLocalPort() + "...");
			try {
				if (selector.select() == 0) // 若沒有事件就緒則不往下執行
					continue;
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			Set<SelectionKey> selectedKeys = selector.selectedKeys(); // 取得所有已就緒事件的key集合
			Iterator<SelectionKey> it = selectedKeys.iterator();
			while (it.hasNext()) {
				dispatch((SelectionKey) (it.next())); // 根據事件的key進行調度
				it.remove();
			}
		}
	}

	/*
	 * name: dispatch(SelectionKey key)
	 * description: 調度方法，根據事件綁定的對象開新線程
	 */
	private void dispatch(SelectionKey key) {
		Runnable r = (Runnable) (key.attachment()); // 根據事件之key綁定的對象開新線程
		if (r != null)
			r.run();
	}

}

[Acceptor.java]

// 接受連線請求線程
package server;

import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class Acceptor implements Runnable {

	private final ServerSocketChannel ssc;
	private final Selector selector;
	
	public Acceptor(Selector selector, ServerSocketChannel ssc) {
		this.ssc=ssc;
		this.selector=selector;
	}
	
	@Override
	public void run() {
		try {
			SocketChannel sc= ssc.accept(); // 接受client連線請求
			System.out.println(sc.socket().getRemoteSocketAddress().toString() + " is connected.");
			
			if(sc!=null) {
				sc.configureBlocking(false); // 設置為非阻塞
				SelectionKey sk = sc.register(selector, SelectionKey.OP_READ); // SocketChannel向selector註冊一個OP_READ事件，然後返回該通道的key
				selector.wakeup(); // 使一個阻塞住的selector操作立即返回
				sk.attach(new TCPHandler(sk, sc)); // 給定key一個附加的TCPHandler對象
			}
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	
}

我们先来简单点的，Handler不以​​状态模式实现，只以比较直觉的方式实现。

[TCPHandler.java]

// Handler線程
package server;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TCPHandler implements Runnable {

	private final SelectionKey sk;
	private final SocketChannel sc;

	int state; 

	public TCPHandler(SelectionKey sk, SocketChannel sc) {
		this.sk = sk;
		this.sc = sc;
		state = 0; // 初始狀態設定為READING
	}

	@Override
	public void run() {
		try {
			if (state == 0)
				read(); // 讀取網絡數據
			else
				send(); // 發送網絡數據

		} catch (IOException e) {
			System.out.println("[Warning!] A client has been closed.");
			closeChannel();
		}
	}
	
	private void closeChannel() {
		try {
			sk.cancel();
			sc.close();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}

	private synchronized void read() throws IOException {
		// non-blocking下不可用Readers，因為Readers不支援non-blocking
		byte[] arr = new byte[1024];
		ByteBuffer buf = ByteBuffer.wrap(arr);
		
		int numBytes = sc.read(buf); // 讀取字符串
		if(numBytes == -1)
		{
			System.out.println("[Warning!] A client has been closed.");
			closeChannel();
			return;
		}
		String str = new String(arr); // 將讀取到的byte內容轉為字符串型態
		if ((str != null) && !str.equals(" ")) {
			process(str); // 邏輯處理
			System.out.println(sc.socket().getRemoteSocketAddress().toString()
					+ " > " + str);
			state = 1; // 改變狀態
			sk.interestOps(SelectionKey.OP_WRITE); // 通過key改變通道註冊的事件
			sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回
		}
	}

	private void send() throws IOException  {
		// get message from message queue
		
		String str = "Your message has sent to "
				+ sc.socket().getLocalSocketAddress().toString() + "\r\n";
		ByteBuffer buf = ByteBuffer.wrap(str.getBytes()); // wrap自動把buf的position設為0，所以不需要再flip()

		while (buf.hasRemaining()) {
			sc.write(buf); // 回傳給client回應字符串，發送buf的position位置 到limit位置為止之間的內容
		}
		
		state = 0; // 改變狀態
		sk.interestOps(SelectionKey.OP_READ); // 通過key改變通道註冊的事件
		sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回
	}
	
	void process(String str) {
		// do process(decode, logically process, encode)..
		// ..
	}
}

最后是主程序代码

[Main.java]

package server;

import java.io.IOException;

public class Main {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			TCPReactor reactor = new TCPReactor(1333);
			reactor.run();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

下面附上客戶端代碼：

[Client.java]

package main.pkg;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String hostname=args[0];
		int port = Integer.parseInt(args[1]);
		//String hostname="127.0.0.1";
		//int port=1333;
		
		System.out.println("Connecting to "+ hostname +":"+port);
		try {
			Socket client = new Socket(hostname, port); // 連接至目的地
			System.out.println("Connected to "+ hostname);
			
			PrintWriter out = new PrintWriter(client.getOutputStream());
			BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
			BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
			String input;
			
			while((input=stdIn.readLine()) != null) { // 讀取輸入
				out.println(input); // 發送輸入的字符串
				out.flush(); // 強制將緩衝區內的數據輸出
				if(input.equals("exit"))
				{
					break;
				}
				System.out.println("server: "+in.readLine());
			}
			client.close();
			System.out.println("client stop.");
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			System.err.println("Don't know about host: " + hostname);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			System.err.println("Couldn't get I/O for the socket connection");
		}
		
	}

}

下一篇将给出使用多线程的IO多路复用代码实现。