2. 程式人生 > >NIO+reactor模式的網路伺服器設計方案

NIO+reactor模式的網路伺服器設計方案

阿新 • • 發佈：2019-02-13

NIO+reactor 模式的網路伺服器設計方案

1、前言

       在前一篇文章中，介紹了基於 BlockingIO +thread-per-connection 的方案，由於該方案為每一個連線分配一個執行緒，而執行緒裡的大部分操作都是阻塞式的，所以在高併發的情況下，會導致產生大量的執行緒，執行緒間的上下文切換會浪費大量的 CPU 時間，而且每個執行緒是需要佔用堆疊空間的，所以伺服器能分配的執行緒數量也是有限的，當客戶端的併發訪問量達到一定的數量級後，伺服器的資源就會耗盡，可伸縮性差。

根據上面的分析，要提高網路伺服器的可伸縮性，就必須解決兩個問題：

  • 服務端的執行緒數量不能按照客戶端連線數的增大而成線性增長，但又必須能夠併發的響應不斷增加的客戶端請求
  • 執行緒裡的操作邏輯不能是阻塞式的

因此， java1.4 引入了非阻塞式 NIO （ Non-blocking IO ） , 解決了問題 2 ；而採用基於非同步事件通知的 reactor 模式則可以僅僅用一個執行緒來併發的為多個連線服務，這樣就解決了問題 1

2、Reactor 模式

2.1 示例

     首先舉一個生活中的例子來比較 thread-per-connection和 reactor方案

某火車票售票廳，只有 1 個售票視窗工作。兩個乘客 a 、 b 先後來購票，由於 a 先到，所以售票視窗先為 a 服務， b 只能排隊

  • thread-per-connection
    ：

    乘客 a與售票視窗開始溝通時，就相當於在客戶端（乘客 a）與服務端（售票廳）之間建立了一個 connection，服務端為每一個 connection分配一個 thread（售票視窗）。當沒有 thread可以分配時，後續的客戶端請求（乘客 b）就不能及時響應了，所以 b只能排隊。假設存在這種場景，售票視窗的服務員告訴乘客 a票價後，乘客 a準備付款時發現自己忘記了帶錢包，所以乘客 a打電話給家裡人讓他們把錢包送過來，但從 a的家步行到售票廳需要 5分鐘，於是售票視窗的服務員就一直等著（被阻塞），但又不為乘客 b服務，因為她的做事風格（ thread-per-connection）是一定要為一個乘客完完整整服務完後才能接著服務下一位乘客。

   這種情況下，乘客 b 肯定會抱怨，而且 5 分鐘後， b 的後面也肯定排了很多人，售票廳發現這種情況後，就只能選擇再開啟一個售票視窗（分配一個 thread ）為 b 服務，但 b 後面的人也只能排隊。之前那個視窗的服務員一直等著，又不幹活，但工資還是照樣拿，所以售票廳（服務端）的開銷很大。

  • Reactor

    服務員在等待 a 取錢包的過程中，被通知乘客 b 要求服務，所以視窗和 b 建立連線，悲劇的是 b 也沒有帶錢包，需要家裡人送來。此時服務員又被通知 a 的錢包送過來了，所以視窗接著為 a 服務，出票完成後，服務員又被通知 b 的錢包送過來了，所以接著又為 b 服務。這樣，售票廳（服務端）的開銷就小了，現在只需要一個視窗就可以搞定所有事情。

2.2 Reactor 模式的思想：分而治之 + 事件驅動

  • 分而治之：

    一個 connection裡發生的完整的網路處理過程一般分為 accept、 read、 decode、 compute、 encode、 send這幾步。 Reactor將每個步驟對映為一個 task，服務端端的執行緒執行的最小邏輯單元不再是一次完整的網路處理過程，而是更小的 task，且採用非阻塞的執行方式；

  • 事件驅動：

   每個 task對應一個特定的事件，當 task準備就緒時，對應的事件通知就會發出。 Reactor收到事件後，分發給綁定了對應事件的 Handler執行 task。

下圖描述了單執行緒版本的 reactor 模式結構圖。

關鍵概念：

  • Reactor：負責響應事件，分發給綁定了該事件的 handler執行 task
  • Handler：綁定了某類事件，負責執行該事件對應的 task。
  • Acceptor ： Handler 的一種，綁定了 connect 事件。它在系統啟動的時候就已經綁定了 connnect 事件，並註冊到 reactor 中。當有客戶端發起 connect 請求時， reactor 會收到 accept 事件，然後分發給 acceptor 。 acceptor 首先會 accept 新的連線，然後新建一個 handler ，將其與該連線上得 read 事件繫結，並註冊到 reactor 中。

2.3 基於 reactor 的網路互動

  1. 客戶端連線伺服器過程

1)伺服器將綁定了 accept事件的 Acceptor註冊到 Reactor中，準備 accept新的 connection;

2)伺服器啟動 Reactor的事件迴圈處理功能（注意：該迴圈會阻塞，直到收到事件）

3)客戶端 connect伺服器

4)Reactor響應 accept事件，分發給 Acceptor， Acceptor 確定建立一個新的連線。

5)Acceptor建立一個 handler專門服務該 connection後續的請求；

6)Handler繫結該 connection的 read事件，並將自己註冊到 Reactor中

  1. 伺服器處理客戶端請求過程

1)客戶端傳送請求

2)當客戶端的請求資料到達伺服器時， Reactor響應 read事件，分發給綁定了 read事件的 handler（即上面第 6步建立的 handler）

3)Handler執行 task，讀取客戶端的請求資料（此處是非阻塞讀，即如果當前操作會導致當前執行緒阻塞，當前操作會立即返回，並重復執行第 2、 3步，直到客戶端的請求讀取完畢。）

4)解析客戶端請求資料

5)讀取檔案

6)Handler重新繫結 write事件

7)當 connection可以開始 write的時候， Reactor響應 write事件，分發給綁定了 write事件的 handler

8)    Handler 執行 task ，向客戶端傳送檔案（此處是非阻塞寫，即如果當前操作會導致當前執行緒阻塞，當前操作會立即返回，並重復執行第 7 、 8 步，直到檔案全部發送完畢。）

注意：上述兩個過程都是在伺服器的一個執行緒裡完成的，該執行緒響應所有客戶端的請求。譬如服務端在處理客戶端 A 的請求時，如果在第 2 步 read 事件還沒有就緒（或者在第 3 步讀取資料的時候發生阻塞了），則該執行緒會立即重新回到客戶端連線伺服器過程的第 2 步（即事件迴圈處理），等待新的事件通知。如果此時客戶端 B 請求連線，則該執行緒會響應 B 的連線請求，這樣就實現了一個執行緒同時為多個連線服務的效果。

3、 程式碼示例

3.1 NIO的幾個關鍵概念

  • Selector：

Reactor裡的一個核心組成部分，通過呼叫 selector.select()方法，可以知道感興趣的 IO事件裡哪些已經 ready，該方法是阻塞的，直到有 IO事件 ready；通過呼叫 selector.selectedKeys()方法，可以獲取到 selectionKey物件，這些物件關聯有已經 ready的 IO事件。

  • SelectionKey：

當 selector註冊一個 channel時，會產生一個該物件，譬如SelectionKey selectionKey = channel .register(selector, SelectionKey. OP_ACCEPT );它維護著 channel 、 selector 、 IO 事件、 Handler 之間的關係。通過呼叫 attach 方法，可以繫結一個 handler ，譬如： selectionKey.attach(new Acceptor());

  • ServerSocketChannel：

類似於 ServerSocket，唯一的區別在於： ServerSocketChannel可以使用 selector，而且可以設定為非阻塞模式。

  • SocketChannel：

類似於 Socket，唯一的區別在於： SocketChannel可以使用 selector，而且可以設定為非阻塞模式。

  • ByteBuffer ：資料緩衝器，是 NIO 裡將資料移入移出 channel 的唯一方式

3.2 code

注：所有程式碼只用來作為原理的進一步闡述，不能用於生產環境

服務端程式碼如下（單執行緒版本）

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


/**
 * @author jason
 * 
 */
public class NioServer implements Runnable {

	private InetAddress hostAddress;
	private int port;

	private ServerSocketChannel serverChannel;

	private Selector selector;

	public NioServer(InetAddress hostAddress, int port) throws IOException {
		this.hostAddress = hostAddress;
		this.port = port;
		// 初始化selector，繫結服務端監聽套接字、感興趣事件及對應的handler
		this.selector = initSelector();
	}

	public static void main(String[] args) {
		try {
			// 啟動伺服器
			new Thread(new NioServer(null, 9090)).start();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		while (true) {
			try {
				// 選擇事件已經ready的selectionKey，該方法是阻塞的，只有當至少存在selectionKey，或者wakeup方法被呼叫，或者當前執行緒被中斷，才會返回
				selector.select();
				// 迴圈處理每一個事件
				Iterator<SelectionKey> items = selector.selectedKeys()
						.iterator();
				while (items.hasNext()) {
					SelectionKey key = (SelectionKey) items.next();
					items.remove();

					if (!key.isValid()) {
						continue;
					}
					// 事件處理分發
					dispatch(key);
				}

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

	}

	/**
	 * 事件處理分發
	 * 
	 * @param sk
	 *            已經ready的selectionKey
	 */
	private void dispatch(SelectionKey sk) {
		// 獲取繫結的handler
		Runnable r = (Runnable) sk.attachment();
		if (r != null) {
			r.run();
		}
	}

	/**
	 * 初始化selector，繫結服務端監聽套接字、感興趣事件及對應的handler
	 * 
	 * @return
	 * @throws IOException
	 */
	private Selector initSelector() throws IOException {
		// 建立一個selector
		Selector socketSelector = SelectorProvider.provider().openSelector();
		// 建立並開啟ServerSocketChannel
		serverChannel = ServerSocketChannel.open();
		// 設定為非阻塞
		serverChannel.configureBlocking(false);
		// 繫結埠
		serverChannel.socket().bind(new InetSocketAddress(hostAddress, port));
		// 用selector註冊套接字，並返回對應的SelectionKey，同時設定Key的interest set為監聽客戶端連線事件
		SelectionKey selectionKey = serverChannel.register(socketSelector,
				SelectionKey.OP_ACCEPT);
		// 繫結handler
		selectionKey.attach(new Acceptor());

		return socketSelector;
	}

	/**
	 * 處理OP_ACCEPT事件的handler
	 * 
	 */
	class Acceptor implements Runnable {
		@Override
		public void run() {
			try {
				accept();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}

		private void accept() throws IOException {
			System.out.println("connect");
			// 建立連線
			SocketChannel socketChannel = serverChannel.accept();
			System.out.println("connected");
			// 設定為非阻塞
			socketChannel.configureBlocking(false);
			// 建立Handler,專門處理該連線後續發生的OP_READ和OP_WRITE事件
			new Handler(selector, socketChannel);
		}

	}

}
handler程式碼如下

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

/**
 * @author jason
 * 
 */
final class Handler implements Runnable {
	final SocketChannel socketChannel;
	final SelectionKey key;
	static final int MAXIN = 8192, MAXOUT = 11240 * 1024;
	ByteBuffer readBuffer = ByteBuffer.allocate(MAXIN);
	ByteBuffer outBuffer = ByteBuffer.allocate(MAXOUT);
	static final int READING = 0;
	static final int SENDING = 1;
	int state = READING;

	Handler(Selector selector, SocketChannel socketChannel) throws IOException {
		this.socketChannel = socketChannel;
		// 用selector註冊套接字，並返回對應的SelectionKey，同時設定Key的interest set為監聽該連線上得read事件
		this.key = socketChannel.register(selector, SelectionKey.OP_READ);
		// 繫結handler
		this.key.attach(this);
	}

	/**
	 * 處理write
	 * 
	 * @throws IOException
	 */
	private void write() throws IOException {
		socketChannel.write(outBuffer);
		if (outBuffer.remaining() > 0) {
			return;
		}
		state = READING;
		key.interestOps(SelectionKey.OP_READ);
	}

	/**
	 * 處理read
	 * 
	 * @throws IOException
	 */
	private void read() throws IOException {
		readBuffer.clear();
		int numRead;
		try {
			// 讀取資料
			numRead = socketChannel.read(readBuffer);
		} catch (Exception e) {
			key.cancel();
			socketChannel.close();
			return;
		}

		if (numRead == -1) {
			socketChannel.close();
			key.cancel();
			return;
		}
		// 處理資料
		process(numRead);

	}

	/**
	 * 處理資料
	 * 
	 * @param numRead
	 */
	private void process(int numRead) {
		byte[] dataCopy = new byte[numRead];
		System.arraycopy(readBuffer.array(), 0, dataCopy, 0, numRead);
		System.out.println(new String(dataCopy));
		outBuffer = ByteBuffer.wrap(dataCopy);
		state = SENDING;
		// 設定Key的interest set為監聽該連線上的write事件
		key.interestOps(SelectionKey.OP_WRITE);
	}

	@Override
	public void run() {
		try {
			if (state == READING) {
				read();
			} else if (state == SENDING) {
				write();
			}

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

	}
}
客戶端程式碼如下：

package sampleNio;

import java.io.IOException;
import java.net.InetAddress;
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.nio.channels.spi.SelectorProvider;
import java.util.Iterator;

/**
 * @author jason
 * 
 */
public class NioClient implements Runnable {
	private InetAddress hostAddress;
	private int port;
	private Selector selector;
	private ByteBuffer readBuffer = ByteBuffer.allocate(8192);
	private ByteBuffer outBuffer = ByteBuffer.wrap("nice to meet you"
			.getBytes());

	public NioClient(InetAddress hostAddress, int port) throws IOException {
		this.hostAddress = hostAddress;
		this.port = port;
		initSelector();
	}

	public static void main(String[] args) {
		try {
			NioClient client = new NioClient(
					InetAddress.getByName("localhost"), 9090);
			new Thread(client).start();

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

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

				Iterator<?> selectedKeys = selector.selectedKeys().iterator();
				while (selectedKeys.hasNext()) {
					SelectionKey key = (SelectionKey) selectedKeys.next();
					selectedKeys.remove();

					if (!key.isValid()) {
						continue;
					}

					if (key.isConnectable()) {
						finishConnection(key);
					} else if (key.isReadable()) {
						read(key);
					} else if (key.isWritable()) {
						write(key);
					}

				}

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

	}

	private void initSelector() throws IOException {
		// 建立一個selector
		selector = SelectorProvider.provider().openSelector();
		// 開啟SocketChannel
		SocketChannel socketChannel = SocketChannel.open();
		// 設定為非阻塞
		socketChannel.configureBlocking(false);
		// 連線指定IP和埠的地址
		socketChannel
				.connect(new InetSocketAddress(this.hostAddress, this.port));
		// 用selector註冊套接字，並返回對應的SelectionKey，同時設定Key的interest set為監聽服務端已建立連線的事件
		socketChannel.register(selector, SelectionKey.OP_CONNECT);
	}

	private void finishConnection(SelectionKey key) throws IOException {
		SocketChannel socketChannel = (SocketChannel) key.channel();
		try {
			// 判斷連線是否建立成功，不成功會拋異常
			socketChannel.finishConnect();
		} catch (IOException e) {
			key.cancel();
			return;
		}
		// 設定Key的interest set為OP_WRITE事件
		key.interestOps(SelectionKey.OP_WRITE);
	}

	/**
	 * 處理read
	 * 
	 * @param key
	 * @throws IOException
	 */
	private void read(SelectionKey key) throws IOException {
		SocketChannel socketChannel = (SocketChannel) key.channel();
		readBuffer.clear();
		int numRead;
		try {
			numRead = socketChannel.read(readBuffer);
		} catch (Exception e) {
			key.cancel();
			socketChannel.close();
			return;
		}
		if (numRead == 1) {
			System.out.println("close connection");
			socketChannel.close();
			key.cancel();
			return;
		}
		// 處理響應
		handleResponse(socketChannel, readBuffer.array(), numRead);
	}

	/**
	 * 處理響應
	 * 
	 * @param socketChannel
	 * @param data
	 * @param numRead
	 * @throws IOException
	 */
	private void handleResponse(SocketChannel socketChannel, byte[] data,
			int numRead) throws IOException {
		byte[] rspData = new byte[numRead];
		System.arraycopy(data, 0, rspData, 0, numRead);
		System.out.println(new String(rspData));
		socketChannel.close();
		socketChannel.keyFor(selector).cancel();
	}

	/**
	 * 處理write
	 * 
	 * @param key
	 * @throws IOException
	 */
	private void write(SelectionKey key) throws IOException {
		SocketChannel socketChannel = (SocketChannel) key.channel();
		socketChannel.write(outBuffer);
		if (outBuffer.remaining() > 0) {
			return;
		}
		// 設定Key的interest set為OP_READ事件
		key.interestOps(SelectionKey.OP_READ);
	}

}

4、 Reactor 的其他實現方式

單執行緒版本的 Reactor 最大的優勢是：不需要做併發控制，簡化了實現。缺點是不能充分利用多核 CPU的優勢，因為只有一個執行緒，該執行緒需要執行所有的操作： accept、 read、 decode、 compute、 encode、 send，而其中的 decode、 compute、 encode如果很耗時，則該執行緒就不能及時的響應其他客戶端的請求。

為了解決該問題，可以採用另外兩種版本：

4.1 Worker threads：

Reactor所在的執行緒只需要專心的響應客戶端的請求： accept、 read、 send。對資料的具體處理過程則交給另外的執行緒池。這樣可以提高服務端對客戶端的響應速度，但同時增加了複雜度，也沒有充分利用到多核的優勢，因為 reactor只有一個，譬如同一時刻只能 read一個客戶端的請求資料。

4.2Multiple reactor threads ：

採用多個 reactor ，每個 reactor 都在自己單獨的執行緒裡執行。如果是多核，則可以同時響應多個客戶端的請求。（ Netty 採用的是類似這種方式，boss執行緒池就是多個mainReactor，worker執行緒池就是多個subReactor）

5、總結

本文分析了基於 NIO和 Reactor模式的網路伺服器設計方案，在後續的 blog中將結合 Netty進一步分析高效能網路伺服器的設計。

 本文為原創，轉載請註明出處

相關推薦

NIO+reactor模式的網路伺服器設計方案

NIO+reactor 模式的網路伺服器設計方案 1、前言        在前一篇文章中，介紹了基於 BlockingIO +thread-per-connection 的方案，由於該方案為每一個連線分配一個執行緒，而執行緒裡的大部分操作都是阻塞式的，所以在高併發的情況下，會導致產生大量的執行緒

10種大併發伺服器設計方案

常見併發伺服器方案 迴圈式/迭代式伺服器：短連結 缺點：無法充分利用多核CPU，不適合執行時間較長的服務 併發式伺服器：長連線 (1)主程序負責監聽client的連線請求 (2)當連線建立後，新fork一個子程序與client通訊 適應場景：適用於執行時間比較長的

iOS應用架構談 網路層設計方案

前言 網路層在一個App中也是一個不可缺少的部分，工程師們在網路層能夠發揮的空間也比較大。另外，蘋果對網路請求部分已經做了很好的封裝，業界的AFNetworking也被廣泛使用。其它的ASIHttpRequest，MKNetworkKit啥的其實也都還不錯，但前者已經棄

iOS應用架構談（3）：網路層設計方案

前言 網路層在一個App中也是一個不可缺少的部分，工程師們在網路層能夠發揮的空間也比較大。另外，蘋果對網路請求部分已經做了很好的封裝，業界的AFNetworking也被廣泛使用。其它的ASIHttpRequest，MKNetworkKit啥的其實也都還不錯，但前者已經棄坑，後者

幀同步--競技類網路遊戲設計方案

一、 前言 幀同步，根據wiki百科的定義是，一種對同步源進行畫素級同步顯示的處理技術，對於網路上的多個接入者，一個訊號將會通過主機同步傳送給其他人，並同步顯示在各個終端上。同步訊號可以是每幀的畫素資料，也可以是影響資料變化的關鍵事件資訊。 幀同步在網路遊戲中的應用，

從Jetty、Tomcat和Mina中提煉NIO構架網路伺服器的經典模式（一）

如何正確使用NIO來構架網路伺服器一直是最近思考的一個問題，於是乎分析了一下Jetty、Tomcat和Mina有關NIO的原始碼，發現大夥都基於類似的方式，我感覺這應該算是NIO構架網路伺服器的經典模式，並基於這種模式寫了個小小網路伺服器，壓力測試了一下，效果還不錯。廢話不多

reactor模式與java nio

time handlers write syn linu pipe accept 事件處理 schmidt ?? Reactor是由Schmidt, Douglas C提出的一種模式，在高並發server實現中廣泛採用。改模式採用事件驅動方式，當事件出現時，後調用對應的

moduo網路庫的reactor模式（中）

moduo網路庫的reactor模式基本構成為“non-blocking I/O + I/O multiplexing”，程式的基本結構是一個事件迴圈（event loop），以事件驅動（event-driven）和事件回撥（event callback）的方式實現業務邏輯。在moduo網路庫的re

大型企業網路系統整合方案如何設計？

網路系統整合是企業實現無紙化辦公和即時通訊辦公的基礎建設，在以生產效率為核心競爭力的市場中，企業想要快速獲取資訊並有效提高企業工作效率及業務能力，企業網路系統整合是必不可少的，由於目前網路技術複雜多樣化，企業網路系統整合不再那麼簡單，必須經過詳細、周密的規劃設計，才能確保網路系統達到目的，那麼企業網路系統整合

Java NIO: Non-blocking Server 非阻塞網路伺服器

本文翻譯自 Jakob Jenkov 的 Java NIO: Non-blocking Server ，原文地址：http://tutorials.jenkov.com/java-nio/non-blocking-server.html 文中所有想法均來自原作者，學習之餘，覺得很不錯，對以後深入學習伺服

從零開始構建一個Reactor模式的網路庫（一） 執行緒同步Mutex和Condition

最近在學習陳碩大神的muduo庫，感覺寫的很專業，以及有一些比較“高階”的技巧和設計方式，自己寫會比較困難。 於是打算自己寫一個簡化版本的Reactor模式網路庫，就取名叫mini吧，同樣只基於Linux平臺，不使用boost庫，去掉一些比較複雜的部分，只實現比較基本的功能。 寫作的過程中，參考了http

Java NIO學習筆記：結合原始碼分析+Reactor模式

Java NIO和IO的主要區別 下表總結了Java NIO和IO之間的主要差別，我會更詳細地描述表中每部分的差異。 IO                           NIO 面向流                     面向緩衝 阻塞IO

Java進階（五）Java I/O模型從BIO到NIO和Reactor模式

本文介紹了Java中的四種I/O模型，同步阻塞，同步非阻塞，多路複用，非同步阻塞。同時將NIO和BIO進行了對比，並詳細分析了基於NIO的Reactor模式，包括經典單執行緒模型以及多執行緒模式和多Reactor模式。 原創文章，轉載請務必將下面這段話置於文章開頭處（保留超連結）。 本文

從零開始構建一個Reactor模式的網路庫（二）執行緒類Thread

執行緒類Thread是對POSIX執行緒的封裝類，因為要構建的是一個Linux環境下的多執行緒網路庫，對執行緒的封裝是很必要的。 首先是CurrentThread名稱空間，主要是獲取以及快取執行緒id： 1 #ifndef CURRENTTHREAD_H 2 #define CURRENTTHR

伺服器開發——Reactor模式

博主的程式碼是C++寫的，本人改成C語言的。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #i

moduo網路庫的reactor模式（下）：實現非阻塞TCP網路

1、在reactor框架下加入tcp Unix下的tcp連線也是經由socket檔案描述符（sockfd）實現的。此節只是封裝了listening sockefd進行監聽（accept(2)），得到的新連線（普通sockfd）直接提供給使用者讓使用者自行處理。下一節才進一步

筆試Java實現單例設計模式（最優方案）

public class SingletonTest { private SingletonTest() //建構函式私有化 {

從半同步-半非同步模式談伺服器的設計

半同步-半非同步模式,最早應該是由ACE的作者提出,原文在這裡.簡而言之,所謂的半同步半非同步模式分為三個組成模組:同步處理模組,佇列模組,非同步處理模組.三個模組之間的互動關係如圖:(注:上圖出自這裡)幾個模組的之間的互動為:非同步模組接收可能會非同步到來的各種事件(I/O,訊號等),然後將它們放入

前後端分離模式下的許可權設計方案

前後端分離模式下，所有的互動場景都變成了資料，傳統業務系統中的許可權控制方案在前端已經不再適用，因此引發了我對許可權的重新思考與設計。 許可權控制到底控制的是什麼？ 在理解許可權控制之前，需要明白兩個概念：資源和許可權。什麼是資源，對於一個系統來說，系統內部的所有資訊都可以理解為這個系統的資源。頁面是資源、資

Linux網路程式設計客戶\伺服器設計正規化

1、前言 　　網路程式設計分為客戶端和服務端，伺服器通常分為迭代伺服器和併發伺服器。併發伺服器可以根據多程序或多執行緒進行細分，給每個連線建立一個獨立的程序或執行緒，或者預先分配好多個程序或執行緒等待連線的請求。今天探討三種設計正規化 （1）迭代伺服器 （2）併發伺服器，為每個客戶請求建立一個程