2. 程式人生 > >NIO學習-04網路通訊

NIO學習-04網路通訊

阿新 • • 發佈：2018-12-28

網路通訊：

       傳統的 IO 流都是阻塞式的。也就是說，當一個執行緒呼叫 read() 或 write() 時，該執行緒被阻塞，直到有一些資料被讀取或寫入，該執行緒在此期間不能執行其他任務。因此，在完成網路通訊進行 IO 操作時，由於執行緒會阻塞，所以伺服器端必須為每個客戶端都提供一個獨立的執行緒進行處理，當伺服器端需要處理大量客戶端時，效能急劇下降。例如tomcat低版本的BIO模式就是傳統的IO流網路通訊。

       Java NIO 是使用Java的非同步IO技術，不產生阻塞。當執行緒從某通道進行讀寫資料時，若沒有資料可用時，該執行緒可以進行其他任務。執行緒通常將非阻塞 IO 的空閒時間用於在其他通道上執行 IO 操作

，所以單獨的執行緒可以管理多個輸入和輸出通道。因此，NIO可以讓伺服器端使用一個或有限幾個執行緒來同時處理連線到伺服器端的所有客戶。

NIO 完成網路通訊的三個核心：

 1. 通道（Channel）：負責連線  
        java.nio.channels.Channel 介面：
             |--SelectableChannel
                 |--SocketChannel
                 |--ServerSocketChannel
                 |--DatagramChannel
 
                 |--Pipe.SinkChannel
                 |--Pipe.SourceChannel
 2. 緩衝區（Buffer）：負責資料的存取
 3. 選擇器（Selector）：是 SelectableChannel 的多路複用器

。用於監控 SelectableChannel 的 IO 狀況.也就是說，利用 Selector 可使一個單獨的執行緒管理多個 Channel。Selector 是非阻塞 IO 的核心。

  

 選擇器（Selector）的應用：

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

        向選擇器註冊通道：SelectableChannel.register(Selector sel, int ops)

ops事件型別： SelectionKey 的四個常量表示

  • 讀 : SelectionKey.OP_READ（1）
  • 寫 : SelectionKey.OP_WRITE（4）
  • 連線 : SelectionKey.OP_CONNECT（8）
  • 接收 : SelectionKey.OP_ACCEPT（16）

若註冊時不止監聽一個事件，則可以使用“位或”操作符連：

   sChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);

SelectionKey:表示 SelectableChannel 和 Selector 之間的註冊關係。每次向選擇器註冊通道時就會選擇一個事件(選擇鍵)。選擇鍵包含兩個表示為整數值的操作集。操作集的每一位都表示該鍵的通道所支援的一類可選擇操作.

 相關API:

int interestOps() 獲取感興趣事件集合
int readyOps() 獲取通道已經準備就緒的操作的集合
SelectableChannel channel() 獲取註冊通道
Selector selector() 返回選擇器
boolean isReadable() 檢測 Channal 中讀事件是否就緒
boolean isWritable() 檢測 Channal 中

Selector 的常用方法:

Set<SelectionKey> keys() 所有的 SelectionKey 集合。代表註冊在該Selector上的Channel
selectedKeys() 被選擇的 SelectionKey 集合。返回此Selector的已選擇鍵集
int select() 監控所有註冊的Channel，當它們中間有需要處理的 IO 操作時，該方法返回，並將對應得的 SelectionKey 加入被選擇的SelectionKey 集合中，該方法返回這些 Channel 的數量.
int select(long timeout) 可以設定超時時長的 select() 操作
int selectNow() 執行一個立即返回的 select() 操作，該方法不會阻塞執行緒
Selector wakeup() 使一個還未返回的 select() 方法立即返回
void close() 關閉該選擇器

管道 (Pipe):

     Java NIO 管道是2個執行緒之間的單向資料連線。Pipe有一個source通道和一個sink通道。資料會被寫到sink通道，從source通道讀取.

   

阻塞與非阻塞案例分析：

   阻塞是：前面一個客戶端沒有執行完，後面的客戶端傳送的訊息無法顯示，因為伺服器還沒有接受完前一個客戶端傳送的訊息，因而後面的客戶端只能處於等待顯示狀態。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;
/**
*TCP
*/
public class TestBlockingNIO2 {
	
	//客戶端
	@Test
	public void client() throws IOException{
		//1. 獲取通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
		
		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
		
		//2. 分配指定大小的緩衝區
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//3. 讀取本地檔案，併發送到服務端
		while(inChannel.read(buf) != -1){
			buf.flip();
			sChannel.write(buf);
			buf.clear();
		}
		//通道停止輸出
		sChannel.shutdownOutput();
		
		//接收服務端的反饋
		int len = 0;
		while((len = sChannel.read(buf)) != -1){
			buf.flip();
			System.out.println(new String(buf.array(), 0, len));
			buf.clear();
		}
		//4. 關閉通道
		inChannel.close();
		sChannel.close();
	}
	
	//服務端
	@Test
	public void server() throws IOException{
		//1. 獲取通道
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		
		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
		
		//2. 繫結連線
		ssChannel.bind(new InetSocketAddress(9898));
		
		//3. 獲取客戶端連線的通道
		SocketChannel sChannel = ssChannel.accept();
		
		//4. 分配指定大小的緩衝區
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//5. 接收客戶端的資料，並儲存到本地
		while(sChannel.read(buf) != -1){
			buf.flip();//實質是令limit=position；position=0
			outChannel.write(buf);
			buf.clear();
		}
		
		//傳送反饋給客戶端
		buf.put("服務端接收資料成功".getBytes());
		buf.flip();
		sChannel.write(buf);
		
		sChannel.close();
		outChannel.close();
		ssChannel.close();
	}

}

非阻塞：

 tcp:

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.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

public class TestNonBlockingNIO {
	
	//客戶端
	@Test
	public void client() throws IOException{
		//1. 獲取通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
		
		//2. 切換非阻塞模式
		sChannel.configureBlocking(false);
		
		//3. 分配指定大小的緩衝區
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//4. 傳送資料給服務端
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + "\n" + str).getBytes());
			buf.flip();
			sChannel.write(buf);
			buf.clear();
		}
		
		//5. 關閉通道
		sChannel.close();
	}

	//服務端
	@Test
	public void server() throws IOException{
		//1. 獲取通道
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		
		//2. 切換非阻塞模式
		ssChannel.configureBlocking(false);
		
		//3. 繫結連線
		ssChannel.bind(new InetSocketAddress(9898));
		
		//4. 獲取選擇器
		Selector selector = Selector.open();
		
		//5. 將通道註冊到選擇器上, 並且指定“監聽接收事件”
		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
		
		//6. 輪詢式的獲取選擇器上已經“準備就緒”的事件
		while(selector.select() > 0){
			
			//7. 獲取當前選擇器中所有註冊的“選擇鍵(已就緒的監聽事件)”
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			
			while(it.hasNext()){
				//8. 獲取準備“就緒”的是事件
				SelectionKey sk = it.next();
				
				//9. 判斷具體是什麼事件準備就緒
				if(sk.isAcceptable()){
					//10. 若“接收就緒”，獲取客戶端連線
					SocketChannel sChannel = ssChannel.accept();
					
					//11. 切換非阻塞模式
					sChannel.configureBlocking(false);
					
					//12. 將該通道註冊到選擇器上
					sChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
				}else if(sk.isReadable()){
					//13. 獲取當前選擇器上“讀就緒”狀態的通道
					SocketChannel sChannel = (SocketChannel) sk.channel();
					
					//14. 讀取資料
					ByteBuffer buf = ByteBuffer.allocate(1024);
					
					int len = 0;
					while((len = sChannel.read(buf)) > 0 ){
						buf.flip();
						System.out.println(new String(buf.array(), 0, len));
						buf.clear();
					}
				}
				
				//15. 取消選擇鍵 SelectionKey
				it.remove();
			}
		}
	}
}

 UDP:

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

import org.junit.Test;
/**
*
* UDP 客戶端讀 服務端 寫
*/
public class TestNonBlockingNIO2 {
	
	/**
	*服務端
	*/
	@Test
	public void send() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		//切換非阻塞模式
		dc.configureBlocking(false);
		
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + ":\n" + str).getBytes());
			buf.flip();
			dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
			buf.clear();
		}
		
		dc.close();
	}
	/**
	*客戶端
	*/
	@Test
	public void receive() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		//切換非阻塞模式
		dc.configureBlocking(false);
		
		dc.bind(new InetSocketAddress(9898));
		
		//獲取選擇器
		Selector selector = Selector.open();
		
		dc.register(selector, SelectionKey.OP_READ);
        // 所有的選擇器選擇物件
		while(selector.select() > 0){
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			
			while(it.hasNext()){
				SelectionKey sk = it.next();
				//讀就緒
				if(sk.isReadable()){
					ByteBuffer buf = ByteBuffer.allocate(1024);
					
					dc.receive(buf);
					buf.flip();
					System.out.println(new String(buf.array(), 0, buf.limit()));
					buf.clear();
				}
			}
			
			it.remove();
		}
	}

}

   管道：

@Test
public void test1() throws IOException{
		//1. 獲取管道
		Pipe pipe = Pipe.open();
		
		//2. 將緩衝區中的資料寫入管道
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Pipe.SinkChannel sinkChannel = pipe.sink();
		buf.put("通過單向管道傳送資料".getBytes());
		buf.flip();
		sinkChannel.write(buf);
		
		//3. 讀取緩衝區中的資料
		Pipe.SourceChannel sourceChannel = pipe.source();
		buf.flip();
		int len = sourceChannel.read(buf);
		System.out.println(new String(buf.array(), 0, len));
		
		sourceChannel.close();
		sinkChannel.close();
	}

 

相關推薦

NIO學習-04網路通訊

網路通訊：        傳統的 IO 流都是阻塞式的。也就是說，當一個執行緒呼叫 read() 或 write() 時，該執行緒被阻塞，直到有一些資料被讀取或寫入，該執行緒在此期間不能執行其他任務。因此，在完成網路通訊進行 IO 操作時，由於執行緒會

Unity 3D學習(三) - 網路通訊

目前沒有找到合適的教程, 暫以此為學習大綱: Unity3D網路通訊_圖文_百度文庫 第一章　網路遊戲與單機遊戲的區別 內容： 網路和單機遊戲對比。 網路遊戲的特點。 介紹網路的幾種實現方式。 介紹本月實現的案例。 考核內

Java學習day26-網路通訊

1.Socket機制               A:通訊兩端都應該有Socket物件B:所有的通訊都是通過Socket間的IO進行操作的2.Socket通訊原理圖解3.UDP協議下發送接收資料傳送：建立UDP傳送端的Socket物件                     

Java NIO 學習筆記（四）----檔案通道和網路通道

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Java NIO 學習筆記（三）----Selector Java NIO 學習筆記（四）----檔案通道和網路通道 FileChannel 檔案通道 Fil

（六）Linux學習筆記-Linux常用命令-網路通訊與關機重啟

（六）Linux學習筆記-Linux常用命令-網路通訊與關機重啟 網路通訊 write（給另外一個使用者發信息） wall（向所有使用者廣播資訊） ping（測試網路連通性） ifconfig（檢視網路設定） 關機重

Docker網路通訊openvswitch（來自龍果學院學習資料 + 自己實驗結果）

1、 拓撲如下： 為了更方便的管理Docker網路，我們這一講使用openvswitch網橋的方式來對容器網路進行管理，實現容器啟動後能夠互通。Open vSwitch是一個高質量的、多層虛擬

JAVA網路通訊之NIO

本篇將展現JAVA網路通訊中NIO的部分，和上一篇不同，本篇所用的Socket是通過SocketChannel的方式，這是NIO與傳統IO最主要的區別。 一、基於緩衝的SocketChannel 和傳統的IO基於流的方式不同，NIO採用基於緩衝的方式。二者的最重要的區

Java nio完成網路通訊（三）

使用Java nio實現網路通訊。 以下是用nio實現簡單網路通訊的demo /** * 使用NIO完成網路通訊 * *1.通道channel：負責連線 * java.nio.channels.Channel * |--selectableChannel *

訊息中介軟體—簡談Kafka中的NIO網路通訊模型

摘要：很多人喜歡把RocketMQ與Kafka做對比，其實這兩款訊息佇列的網路通訊層還是比較相似的，本文就為大家簡要地介紹下Kafka的NIO網路通訊模型 前面寫的兩篇RocketMQ原始碼研究筆記系列： （1） 訊息中介軟體—RocketMQ的RPC通訊（一）

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

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

高效能網路通訊框架Netty-Netty客戶端底層與Java NIO對應關係

5.1 Netty客戶端底層與Java NIO對應關係 在講解Netty客戶端程式時候我們提到指定NioSocketChannel用於建立客戶端NIO套接字通道的例項，下面我們來看NioSocketChannel是如何建立一個Java NIO裡面的SocketChannel的。 首先我們來看

Tomcat 連線數與執行緒池詳解 | BIO/NIO有何不同 | 簡談Kafka中的NIO網路通訊模型

前言 在使用tomcat時，經常會遇到連線數、執行緒數之類的配置問題，要真正理解這些概念，必須先了解Tomcat的聯結器（Connector）。 在前面的文章 詳解Tomcat配置檔案server.xml 中寫到過：Connector的主要功能，是接收連線請求，建立Req

c#--.net網路通訊學習1

一、服務端程式碼 1、建立服務端socket  Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 2、將ipv4地址轉換為ipAd

C++高併發網路通訊引擎學習記錄。

2018.11.19 週一 學了 C/C++ 語言這麼久了，從來沒有真正的做過一個完整的專案，總覺得缺了點什麼，所以決定找一個專案來認認真真跟著做。最後在朋友的推薦下選擇了劉向東的《C++百萬併發網路通訊引擎架構與實現》，學習這個專案我大概給自己規劃了3個學習階段: 跟著老師

【 專欄 】- Java NIO 與 Netty 網路程式設計學習筆記

Java NIO 與 Netty 網路程式設計學習筆記 以一個IM聊天功能的實現。記錄筆者從最原始的阻塞IO(BIO)到JDK1.4提供的非阻塞IO，再到JDK 1.7 非同步IO的學習筆記，最後到Netty框架的學習筆記。

《Java開發實戰1200例》（第2卷）學習筆記—TCP網路通訊

例項313：使用Socket通訊 通過Socket類的getInputStream()方法獲得輸入流物件，並藉助InputStreamReader類將輸入流物件轉換為BufferedReader物件讀取接收到的資訊，使用getOutputStream()方法獲

Docker容器學習梳理--容器間網路通訊設定(Pipework和Open vSwitch)

自從Docker容器出現以來，容器的網路通訊就一直是被關注的焦點，也是生產環境的迫切需求。容器的網路通訊又可以分為兩大方面：單主機容器上的相互通訊，和跨主機的容器相互通訊。下面將分別針對這兩方面，對容器的通訊原理進行簡單的分析，幫助大家更好地使用docker。前面已經

NIO,BIO,AIO,JAVA通訊程式設計學習筆記3

下文內容摘自《Netty 權威指南》 JDK1.7升級了NIO類庫，升級後的NIO類庫被稱為NIO2.0，引人注目的是Java正式提供了非同步檔案IO操作，同時提供了與Unix網路程式設計事件驅動IO對應的AIO，下面的2.4章節我們學習下如何利用NIO2.0編寫AIO程

NIO學習之Selector，SelectionKey與客戶端與服務端通訊簡單實現（1）

選擇器（Selector）的 作用：將通道感興趣的事件放入佇列中，而不是馬上提交給應用程式，等已註冊的通道自己來請求處理這些事件。換句話說，就是選擇器將會隨時報告已經準備好了的通道，而且是按照先進先出的順序。 Selector類定義如下： open(

Java NIO學習筆記(四) 使用JDK 1.7 NIO2.0 實現客戶端與伺服器的通訊

JDK1.7 提供了全新的非同步NIO模式。稱為：NIO2.0或AIO。該模式引入了新的非同步通道的概念，並提供了非同步檔案通道和非同步套接字通道的實現。非同步通道提供兩種方式獲取獲取操作結果。分別是： 通過java.util.concurrent