2. 程式人生 > >JavaNIO：非阻塞NIO通訊及相關物件講解

JavaNIO：非阻塞NIO通訊及相關物件講解

阿新 • • 發佈：2019-01-14

1.ServerSocketChannel

ServerSocketChannel是一個基於通道的socket監聽器。它同我們所熟悉的java.net.ServerSocket執行相同的基本任務，不過它增加了通道語義，因此能夠在非阻塞模式下執行。它可用靜態的open( )工廠方法建立一個新的ServerSocketChannel物件，將會返回同一個未繫結的java.net.ServerSocket關聯的通道。該對等ServerSocket可以通過在返回的ServerSocketChannel上呼叫socket( )方法來獲取。

在ServerSocket上呼叫accept( )方法，那麼它會同任何其他的ServerSocket表現一樣的行為：總是阻塞並返回一個java.net.Socket物件(阻塞的！！！！)

在ServerSocketChannel上呼叫accept( )方法則會返回SocketChannel型別的物件，返回的物件能夠在非阻塞模式下執行。

如果以非阻塞模式被呼叫，當沒有傳入連線在等待時，ServerSocketChannel.accept( )會立即返回null (因為他是非阻塞的所以要有返回，)。正是這種檢查連線而不阻塞的能力實現了可伸縮性並降低了複雜性。可選擇性也因此得到實現。我們可以使用一個選擇器例項來註冊一個ServerSocketChannel物件以實現新連線到達時自動通知的功能。

初始化ServerSocketChannel

/**
	 * 初始化ServerSocketChannel
	 * @throws Exception
	 */
	public void initChannel() throws Exception{
		channel = ServerSocketChannel.open();
		channel.socket().bind(new InetSocketAddress(port));
		channel.configureBlocking(false);//非阻塞模式
		
		selector = Selector.open();
		channel.register(selector, SelectionKey.OP_ACCEPT);
		System.out.println("NIO TCP Push Listener nio provider: "+selector.provider().getClass().getCanonicalName());
	}

2.SocketChannel vs. ServerSocketChannel

  • 父類：SelectableChannel。Channel表現了一個可以進行IO操作的通道（比如，通過FileChannel，我們可以對檔案進行讀寫操作）
  • ServerSocketChannel主要用在Server中，用於接收客戶端的連結請求 ；
    SocketChannel則用於真正的讀寫資料，同時還可以用於客戶端傳送連結請求。
  • 真正實現讀寫資料操作的就是這些SocketChannel，上面的ServerSocketChannel只是負責接收連線請求。
  • 以下均簡稱為channel

2.1channel vs. Selector

  • channel需要註冊到selector上。channel可以註冊到一個或多個Selector上以進行非同步IO操作。

       channel.register(selector, SelectionKey.OP_ACCEPT);

channel.register(selector, xxx, object); //attachment被存放在返回的SelectionKey中

channel.keyFor(selector); //返回該channe在Selector上的註冊關係所對應的SelectionKey。若無註冊關係，返回null。

  • Selector可以同時監控多個SelectableChannel的IO狀況，是非同步IO的核心。

Selector.open(); //靜態方法，建立一個selector例項

       selector.select(); //selector通過呼叫select()，將註冊的channel中有事件發生的取出來進行處理。監控所有註冊的channel，當其中有註冊的IO操作可以進行時，該函式返回，並將對應的SelectionKey加入selected-key set。

       selector.keys(); //所有註冊在這個Selector上的channel

       selector.selectedKeys(); //所有通過select()方法監測到可以進行IO操作的channel

2.2.SelectionKey

  • 代表了Selector和SelectableChannel的註冊關係

       key.attachment(); //返回SelectionKey的attachment，attachment可以在註冊channel的時候指定。

       key.channel(); // 返回該SelectionKey對應的channel。

       key.selector(); // 返回該SelectionKey對應的Selector。

key.interestOps(); //返回代表需要Selector監控的IO操作的bit mask

       key.readyOps(); //返回一個bit mask，代表在相應channel上可以進行的IO操作。

2.3Channel,Selector &SelectionKey示例程式碼

package com.boonya.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
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;
import java.util.Set;

public class JustPartCode {

	String host = "192.168.1.137";

	int port = 9901;

	SocketChannel channel;

	Selector selector = null;
	
	/**
	 * 為Selector註冊channel
	 * @throws IOException
	 */
	public void initSelector() throws IOException{
		selector=Selector.open();
		channel.register(selector, SelectionKey.OP_ACCEPT);
	}

	/**
	 * Server端處理Selector註冊的事件
	 * 
	 * @throws IOException
	 */
	public void handEvent() throws IOException {
		// 得到selector所捕獲的事件數量
		int n = selector.select();
		// 當真正捕獲到事件時，才執行相應操作
		if (n > 0) {
			// 獲取捕獲到的事件集合
			Set selectedKeys = selector.selectedKeys();
			Iterator i = selectedKeys.iterator();
			while (i.hasNext()) {
				// 對事件一一處理
				SelectionKey s = (SelectionKey) i.next();
				// 一個key被處理完成後，就都被從就緒關鍵字（ready keys）列表中除去
				i.remove();
				if (s.isAcceptable()) // 表示該事件為OP_ACCEPT事件
				{
					// 從channel()中取得我們剛剛註冊的ServerSocketChannel
					// 為請求獲取新的SocketChannel
					SocketChannel sc = ((ServerSocketChannel) s.channel())
							.accept().socket().getChannel();
					// 設定SocketChannel為非阻塞方式
					sc.configureBlocking(false);
					// 將新的SocketChannel註冊到selector中，註冊事件為OP_READ和OP_WRITE
					sc.register(selector, SelectionKey.OP_READ
							| SelectionKey.OP_WRITE);

				} else {
					// 執行其他操作
				}
			}
		}
	}

	/**
	 * Server端讀取通道資料
	 * 
	 * @throws IOException
	 */
	public void readDataFromChannel() throws IOException {
		// 獲取捕獲到的事件集合
		Set selectedKeys = selector.selectedKeys();
		Iterator i = selectedKeys.iterator();
		while (i.hasNext()) {
			// 對事件一一處理
			SelectionKey key = (SelectionKey) i.next();
			// 一個key被處理完成後，就都被從就緒關鍵字（ready keys）列表中除去
			i.remove();
			ByteBuffer clientBuffer = ByteBuffer.allocate(4096);
			// 讀資訊
			if (key.isReadable()) {
				// 獲取相應的SocketChannel
				SocketChannel channel = (SocketChannel) key.channel();
				// 將資料讀入clientBuffer
				int count = channel.read(clientBuffer);
				// 當有資料讀入時
				if (count > 0) {
					// 反轉此緩衝區
					clientBuffer.flip();
					// 如果需要，對緩衝區中的字元進行解碼
					// CharBuffer charBuffer = decoder.decode(clientBuffer);
				}
			}
		}
	}

	/**
	 * 客戶端向服務端傳送資料
	 * 
	 * @throws IOException
	 */
	public void clientSendData() throws IOException {
		InetSocketAddress addr = new InetSocketAddress(host, port);
		// 生成一個socketchannel
		channel = SocketChannel.open();
		// 連線到server
		channel.connect(addr);
		// 當連線成功時，執行相應操作
		if (channel.finishConnect()) {
			// 準備資料
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			buffer.put("Hello stupid server".getBytes());
			buffer.flip(); // 反轉此緩衝區
			while (buffer.hasRemaining())
				// 傳送資料到server
				channel.write(buffer);
		}
	}
}

3.Selector詳解

Selector（選擇器）是Java NIO中能夠檢測一到多個NIO通道，並能夠知曉通道是否為諸如讀寫事件做好準備的元件。這樣，一個單獨的執行緒可以管理多個channel，從而管理多個網路連線。

3.1為什麼使用Selector?

僅用單個執行緒來處理多個Channels的好處是，只需要更少的執行緒來處理通道。事實上，可以只用一個執行緒處理所有的通道。對於作業系統來說，執行緒之間上下文切換的開銷很大，而且每個執行緒都要佔用系統的一些資源（如記憶體）。因此，使用的執行緒越少越好。

但是，需要記住，現代的作業系統和CPU在多工方面表現的越來越好，所以多執行緒的開銷隨著時間的推移，變得越來越小了。實際上，如果一個CPU有多個核心，不使用多工可能是在浪費CPU能力。不管怎麼說，關於那種設計的討論應該放在另一篇不同的文章中。在這裡，只要知道使用Selector能夠處理多個通道就足夠了。

下面是單執行緒使用一個Selector處理3個channel的示例圖：

3.2Selector的建立

通過呼叫Selector.open()方法建立一個Selector，如下：

Selector selector = Selector.open();

3.3向Selector註冊通道

為了將Channel和Selector配合使用，必須將channel註冊到selector上。通過SelectableChannel.register()方法來實現，如下：

channel.configureBlocking(false);
SelectionKey key = channel.register(selector,Selectionkey.OP_READ);

與Selector一起使用時，Channel必須處於非阻塞模式下。這意味著不能將FileChannel與Selector一起使用，因為FileChannel不能切換到非阻塞模式。而套接字通道都可以。

注意register()方法的第二個引數。這是一個“interest集合”，意思是在通過Selector監聽Channel時對什麼事件感興趣。可以監聽四種不同型別的事件：

  1. Connect
  2. Accept
  3. Read
  4. Write

通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連線到另一個伺服器稱為“連線就緒”。一個server socket channel準備好接收新進入的連線稱為“接收就緒”。一個有資料可讀的通道可以說是“讀就緒”。等待寫資料的通道可以說是“寫就緒”。

這四種事件用SelectionKey的四個常量來表示：

  1. SelectionKey.OP_CONNECT
  2. SelectionKey.OP_ACCEPT
  3. SelectionKey.OP_READ
  4. SelectionKey.OP_WRITE

如果你對不止一種事件感興趣，那麼可以用“位或”操作符將常量連線起來，如下：

1 int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

在下面還會繼續提到interest集合。

3.4SelectionKey

在上一小節中，當向Selector註冊Channel時，register()方法會返回一個SelectionKey物件。這個物件包含了一些你感興趣的屬性：

  • interest集合
  • ready集合
  • Channel
  • Selector
  • 附加的物件（可選）

下面我會描述這些屬性。

3.4.1interest集合

就像向Selector註冊通道一節中所描述的，interest集合是你所選擇的感興趣的事件集合。可以通過SelectionKey讀寫interest集合，像這樣：

1 int interestSet = selectionKey.interestOps();
2
3 boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
4 boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
5 boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
6 boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

可以看到，用“位與”操作interest 集合和給定的SelectionKey常量，可以確定某個確定的事件是否在interest 集合中。

3.4.2ready集合

ready 集合是通道已經準備就緒的操作的集合。在一次選擇(Selection)之後，你會首先訪問這個ready set。Selection將在下一小節進行解釋。可以這樣訪問ready集合：

1 int readySet = selectionKey.readyOps();

可以用像檢測interest集合那樣的方法，來檢測channel中什麼事件或操作已經就緒。但是，也可以使用以下四個方法，它們都會返回一個布林型別：

1 selectionKey.isAcceptable();
2 selectionKey.isConnectable();
3 selectionKey.isReadable();
4 selectionKey.isWritable();
3.4.3Channel + Selector

從SelectionKey訪問Channel和Selector很簡單。如下：

1 Channel  channel  = selectionKey.channel();
2 Selector selector = selectionKey.selector();
3.4.5附加的物件

可以將一個物件或者更多資訊附著到SelectionKey上，這樣就能方便的識別某個給定的通道。例如，可以附加 與通道一起使用的Buffer，或是包含聚集資料的某個物件。使用方法如下：

1 selectionKey.attach(theObject);
2 Object attachedObj = selectionKey.attachment();

還可以在用register()方法向Selector註冊Channel的時候附加物件。如：

1 SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

3.5通過Selector選擇通道

一旦向Selector註冊了一或多個通道，就可以呼叫幾個過載的select()方法。這些方法返回你所感興趣的事件（如連線、接受、讀或寫）已經準備就緒的那些通道。換句話說，如果你對“讀就緒”的通道感興趣，select()方法會返回讀事件已經就緒的那些通道。

下面是select()方法：

  • int select()
  • int select(long timeout)
  • int selectNow()

select()阻塞到至少有一個通道在你註冊的事件上就緒了。

select(long timeout)和select()一樣，除了最長會阻塞timeout毫秒(引數)。

selectNow()不會阻塞，不管什麼通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作後，沒有通道變成可選擇的，則此方法直接返回零。）。

select()方法返回的int值表示有多少通道已經就緒。亦即，自上次呼叫select()方法後有多少通道變成就緒狀態。如果呼叫select()方法，因為有一個通道變成就緒狀態，返回了1，若再次呼叫select()方法，如果另一個通道就緒了，它會再次返回1。如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法呼叫之間，只有一個通道就緒了。

selectedKeys()

一旦呼叫了select()方法，並且返回值表明有一個或更多個通道就緒了，然後可以通過呼叫selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示：

1 Set selectedKeys = selector.selectedKeys();

當像Selector註冊Channel時，Channel.register()方法會返回一個SelectionKey 物件。這個物件代表了註冊到該Selector的通道。可以通過SelectionKey的selectedKeySet()方法訪問這些物件。

可以遍歷這個已選擇的鍵集合來訪問就緒的通道。如下：

Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
}

這個迴圈遍歷已選擇鍵集中的每個鍵，並檢測各個鍵所對應的通道的就緒事件。

注意每次迭代末尾的keyIterator.remove()呼叫。Selector不會自己從已選擇鍵集中移除SelectionKey例項。必須在處理完通道時自己移除。下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。

SelectionKey.channel()方法返回的通道需要轉型成你要處理的型別，如ServerSocketChannel或SocketChannel等。

3.6wakeUp()

某個執行緒呼叫select()方法後阻塞了，即使沒有通道已經就緒，也有辦法讓其從select()方法返回。只要讓其它執行緒在第一個執行緒呼叫select()方法的那個物件上呼叫Selector.wakeup()方法即可。阻塞在select()方法上的執行緒會立馬返回。

如果有其它執行緒呼叫了wakeup()方法，但當前沒有執行緒阻塞在select()方法上，下個呼叫select()方法的執行緒會立即“醒來（wake up）”。

3.7close()

用完Selector後呼叫其close()方法會關閉該Selector，且使註冊到該Selector上的所有SelectionKey例項無效。通道本身並不會關閉。

3.8完整的示例

這裡有一個完整的示例，開啟一個Selector，註冊一個通道註冊到這個Selector上(通道的初始化過程略去),然後持續監控這個Selector的四種事件（接受，連線，讀，寫）是否就緒。

Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
while(true) {
  int readyChannels = selector.select();
  if(readyChannels == 0) continue;
  Set selectedKeys = selector.selectedKeys();
  Iterator keyIterator = selectedKeys.iterator();
  while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
  }
}

4.NIO非阻塞任務處理例項

ServerSocketChannel在執行前設定成非堵塞模式 然後註冊到實際進行任務處理的Dispather執行緒的Selector中。

package com.boonya.nio;

import java.io.IOException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Dispatcher implements Runnable {

	Selector selector;
	
	ExecutorService pool=Executors.newFixedThreadPool(20);

	@Override
	public void run() {
		while (true) {
			try {
				dispatch();
			} catch (IOException e) {
				System.out.println(e);
			}
		}
	}

	private void dispatch() throws IOException {
		selector.select();
		for (Iterator<SelectionKey> itor = selector.selectedKeys().iterator(); itor
				.hasNext();) {
			SelectionKey sk = itor.next();
			itor.remove();
			if (sk.isAcceptable()) {
				ServerSocketChannel serverSocketChannel = (ServerSocketChannel) sk
						.channel();
				SocketChannel sc = serverSocketChannel.accept();
				sc.configureBlocking(false);

				RequestHandler handler = new RequestHandler(sc);
				sc.register(selector, SelectionKey.OP_READ,handler);
			} else if (sk.isReadable()) {
				SocketChannel sc = (SocketChannel) sk.channel();
				try {
					int count = selector.select();
					// 小於零 意味著要麼就是傳過來的沒有資訊 要麼就是有異常了
					if (count < 0) {
						sk.cancel();
						sc.close();
						continue;
					}
					// 等於零的情況 繼續
					if (count <= 0) {
						sk.cancel();
						sc.close();
						continue;
					}
				} catch (Exception e) {
					System.out.println("NIODiapatcher dispatch()"+e.getMessage());
					sk.cancel();
					sc.close();
					continue;
				}
				RequestHandler handler=(RequestHandler) sk.attachment();
				pool.execute(handler);
			}
		}
	}

	public void register(ServerSocketChannel ssc, int ops) {
		try {
			ssc.register(selector, ops);
		} catch (ClosedChannelException e) {

		}
	}
	
	public class RequestHandler implements Runnable{
		
		SocketChannel channel;

		public  RequestHandler(SocketChannel channel){
			this.channel=channel;
		}
		
		@Override
		public void run() {
			
		}
		
	}
}


參考資料：http://ifeve.com/selectors/，http://flym.iteye.com/blog/392350，http://www.tuicool.com/articles/QfeEFz，http://warnerhit.iteye.com/blog/1417744

相關推薦

JavaNIO：非阻塞NIO通訊及相關物件講解

1.ServerSocketChannel ServerSocketChannel是一個基於通道的socket監聽器。它同我們所熟悉的java.net.ServerSocket執行相同的基本任務，不過它增加了通道語義，因此能夠在非阻塞模式下執行。它可用靜態的open( )

Java入門系列-25-NIO(實現非阻塞網路通訊)

還記得之前介紹NIO時對比傳統IO的一大特點嗎？就是NIO是非阻塞式的，這篇文章帶大家來看一下非阻塞的網路操作。 補充：以陣列的形式使用緩衝區 package testnio; import java.io.IOException; import java.io.RandomAccessFile; impo

Java網路程式設計——使用NIO實現非阻塞Socket通訊

       除了普通的Socket與ServerSocket實現的阻塞式通訊外，java提供了非阻塞式通訊的NIO API。先看一下NIO的實現原理。        從圖中可以看出，伺服器上所有Channel（包括ServerSocketChannel和Socket

java NIO 實現非阻塞socket通訊

java的nio為非阻塞式socket通訊提供瞭如下幾個類：           Selector : 它是SelectableChannel物件的多路複用器，所有希望採用非阻塞方式進行通訊的channel都應該註冊到Selector物件。可以通過呼叫此類的open()

Java NIO 非阻塞socket通訊案例

NIO的特性：它以塊為基本單位處理資料，所有的資料都要通過緩衝區（Buffer）來進行傳輸。它有一個用來作為原始I/O操作的抽象通道（Channel）並提供了Selector的非同步網路介面。且支援將檔案對映到記憶體，以大幅提高I/O效率。 緩衝區中有3個重要

java網路程式設計(三)----同步非阻塞nio及reactor模型

很多剛接觸NIO的人，第一眼看到的就是Java相對晦澀的API，比如：Channel，Selector，Socket什麼的；然後就是一坨上百行的程式碼來演示NIO的服務端Demo，所以這裡我們人性化地簡單介紹一下。 NIO我們一般認為是New I/O（也

使用NIO實現非阻塞Socket通訊原理

剛學了NIO，寫一下自己的理解 網路通訊中，NIO提供了SocketChannel和ServerSocketChannel兩種不同的套接字通道來實現，可以設定阻塞與非阻塞兩種模式，為了實現高負載高併發都採取非阻塞的模式。通道是雙向的，可以同時在通道上傳送和讀取

【MPI學習4】MPI並行程式設計模式：非阻塞通訊MPI程式設計

這一章講了MPI非阻塞通訊的原理和一些函式介面，最後再用非阻塞通訊方式實現Jacobi迭代，記錄學習中的一些知識。 （1）阻塞通訊與非阻塞通訊 阻塞通訊呼叫時，整個程式只能執行通訊相關的內容，而無法執行計算相關的內容； 非阻塞呼叫的初衷是儘量讓通訊和計算重疊進行，提高程式整體執行效率。 整體對比見下圖：

Thinking in Java--使用NIO實現非阻塞Socket通訊

Java1.4提供了一種新的IO讀取方式，稱為NIO。NIO中使用了通道和緩衝器的概念，並且以塊的形式操作資料，這樣更接近作業系統IO操作的形式，提高了JavaIO的效率。NIO的核心類有兩個Channel和Buffer。但是其實除了提升了基本IO操作的效能外，

VS2010-MFC（對話框：屬性頁對話框及相關類的介紹）

name sbt simple 兩個 點擊 pct dialog hang pos 轉自：http://www.jizhuomi.com/software/164.html 一 屬性頁對話框的分類 屬性頁對話框想必大家並不陌生，XP系統

[Swift4.2實際操作]九、完整例項-(7)登入頁面：建立自定義檢視及相關元件

本文將開始建立登入頁面，首先建立該頁面所需的一些自定義元件：做為登入按鈕的自定義檢視物件。在【RegLogin】組的名稱上點選滑鼠右鍵，開啟右鍵選單。【New File】->【Cocoa Touch Class】建立新檔案【RegButton.swift】Name:RegButtonSubclass:S

基於Java NIO2實現的非同步非阻塞訊息通訊框架

原文傳送門 基於Java NIO2實現的非同步非阻塞訊息通訊框架 前奏 AIO應用開發 Future方式 Callback方式 Reader/Writer方式實現 執行緒池和Group PendingExceptio

遷移學習演算法：多工學習說明及相關的例項

簡介：  多工學習（Multitask learning）是遷移學習演算法的一種，遷移學習可理解為定義一個一個源領域source domain和一個目標領域（target domain），在source domain學習，並把學習到的知識遷移到target domain，提升target

Netty非同步非阻塞事件驅動及元件原理詳解

本文基於 Netty 4.1 展開介紹相關理論模型，使用場景，基本元件、整體架構，知其然且知其所以然，希望給大家在實際開發實踐、學習開源專案方面提供參考。 Netty 是一個非同步事件驅動的網路應用程式框架，用於快速開發可維護的高效能協議伺服器和客戶端。 JDK 原生 NIO 程式的問題

Windows網路程式設計（八）：非阻塞模式（非同步模式）

前面幾篇文章介紹的無論是TCP通訊還是UDP通訊都是阻塞式的，它們在執行recv或recvfrom時會線上程中等待，直到接收到資訊為止，所以在應用的時候一般都需要開闢子執行緒，在子執行緒裡專門做這類事情，不然它會影響主執行緒的執行。  系統提供三種網路模型

ml課程：Sklearn工具庫學習及相關案例程式碼

以下是我的學習筆記，以及總結，如有錯誤之處請不吝賜教。 本文主要介紹sklearn工具庫相關使用，以及部分內容解釋，最後有相關案例程式碼。 首先看一張圖，這張圖是構建機器學習系統的一般流程： 還記得之前的一篇文章中有一張sklearn機器學習模型選擇流程的一張圖與此類似：沒看過

Java IO：BIO和NIO區別及各自應用場景

引言BIO和NIO是兩種不同的網路通訊模型，現如今NIO已經大量應用在Jetty、ZooKeeper、Netty等開源框架中。一個面向流、一個面向緩衝區一個是阻塞式的、一個非阻塞一個沒有io多路複用器、一個有下面通過一個例子解釋兩者區別：假設當前服務端程式需要同時從與多個客戶

非阻塞式通訊詳解

用ServerSocket 和Socket編寫伺服器和客戶端程式的時候，其在執行過程中往往是阻塞的。例如SeverSocket中的accept（）方法，假如沒有客戶連線就一直處於阻塞狀態。JDK1.4 後引入非阻塞式通訊機制，伺服器程式接收客戶連線，客戶程式建立與伺服器的

C++ Windows非阻塞UDP通訊原始碼

UDP通訊中，recvfrom或recv等函式預設都是阻塞方式進行的，即如果沒有收到訊息，那麼程式會一直卡在recv()這個函式這裡，使得該執行緒不能進行後續的操作。但有時候我們需要該執行緒在有UDP資料傳送過來的時候才進行資料接收，而在其他時間該執行緒還有別的

Linux實驗全紀錄之 非阻塞型通訊程式框架

#include<stdio.h> #include<unistd.h> #include<sys/types.h> #include<signal.h> #include<stdlib.h> void sigin