Java 標準IO框架與NIO框架詳解

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

在看這篇文章之前，可以先去看看我部落格中另一篇關於同步與非同步、阻塞與非阻塞的理解

Java標準IO（BIO）

BIO全稱Blocking IO又叫做同步阻塞IO，它存在如下特點：

面向流
同步
阻塞

package com.xdong.bio.client;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class BioClient {
	
	public static void main(String[] args) {
		Socket client = null;
		InputStream inputStream = null;
		OutputStream outputStream = null;
		try {
			client = new Socket("127.0.0.1", 8888);
			inputStream = client.getInputStream();
			outputStream = client.getOutputStream();
			outputStream.write("Hello Server I am conneting you!".getBytes());
			outputStream.flush();
			byte[] bytes = new byte[1024];
			while (inputStream.read(bytes) > 0) {//這裡必須一次讀完才能進行下次讀操作，否則下一次會將上一次的
				String msg = new String(bytes).trim();
				System.out.println("client receive the message of server:" + msg);
				outputStream.write("client get the message !".getBytes());
				outputStream.flush();
				Thread.sleep(1*1000);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

package com.xdong.bio.server;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BioServer {
	private static final ExecutorService THREAD_POOL = Executors.newFixedThreadPool(5);
	
	public static void main(String[] args) {
		ServerSocket server = null;
		Socket socket = null;
		try {
			server = new ServerSocket(8888);
			while (!Thread.interrupted()) {
				socket = server.accept();
				THREAD_POOL.submit(new SocketHandler(socket));
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	static class SocketHandler implements Runnable{
		private Socket socket;
		public SocketHandler(Socket socket) {
			super();
			this.socket = socket;
		}
		@Override
		public void run() {
			InputStream inputStream = null;
			OutputStream outputStream = null;
			try {
				inputStream = socket.getInputStream();
				outputStream = socket.getOutputStream();
				byte[] bs = new byte[1024];
				while (true) {
					int available = inputStream.available();// 輸入流中有多少可用位元組
					inputStream.read(bs, 0, available);//  從輸出流中將資料寫入位元組陣列(注：如果位元組陣列原本有100個位元組，本次讀取50個位元組，那麼它只會覆蓋前面50個位元組資料,位元組陣列中還是有100個位元組資料)
					String receive = new String(bs, 0,available).trim();
					System.out.println("server receive the message of client:" + receive);
					outputStream.write("server get the message!".getBytes());//write函式-阻塞
					outputStream.flush();
					Thread.sleep(1*1000);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

}

簡單分析一下上面程式碼：

繫結一個埠，產生一個SocketServer物件，並呼叫accept()方法，監聽這個埠，接收客戶端連線。
當有客戶端接入後，服務端單獨起一個執行緒，利用socket與客戶端互動。
利用socket.getInputStream流接收客戶端傳送的訊息，利用socket.getOutputStream流傳送訊息給客戶端。
注意：server.accept、inpustream.read、outputstream.write都會阻塞執行緒。
同步體現在服務端與客戶端的互動只能一步步順序進行。阻塞主要體現在第4點中的幾個方法。即使採用了多執行緒技術，實現了主執行緒非阻塞，但是子執行緒中與客戶端互動依舊是阻塞的。

Java NIO框架

NIO，全稱是Non-Blocking IO或New IO，解釋就是非阻塞IO和新版IO。下面將給出三份不同的Server端程式碼，分別表示為：單Selector-單執行緒模式、單Selector-多執行緒模式、多Selector-多執行緒模式。

NIO的特性如下：

面向緩衝區
同步
非阻塞

package com.xdong.nio.v1.server;

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;

/**
 * v1=單執行緒、單reactor
 * @author xiongchaoqun
 * @date 2018年7月2日
 */
public class NioServer {

	public static void main(String[] args) {
		ServerSocketChannel serverSocketChannel = null;// 宣告服務端Channel
		try {
			serverSocketChannel = ServerSocketChannel.open();// 例項化
			serverSocketChannel.bind(new InetSocketAddress(1234));// 繫結埠
			Selector selector = Selector.open();// 例項化一個Selector
			serverSocketChannel.configureBlocking(false);//設定非阻塞，才能進行下面的register
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// 註冊可接受連線監聽
			while (selector.select() > 0) {
				Iterator<SelectionKey> it = selector.selectedKeys().iterator();
				while (it.hasNext()) {
					SelectionKey key = it.next();
					it.remove();// 如果不移除，那麼下次遍歷還會處理這個selectionKey
					if (key.isAcceptable()) {
						handleAcceptEvent(selector,key);
					} else if (key.isReadable()) {
						handleReadEvent(selector,key);
					}
					Thread.sleep(1000);
				}
			}

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

	/**
	 * 處理客戶端接入事件
	 * 
	 * @param key
	 * @throws IOException
	 */
	private static void handleAcceptEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = null;// 客戶端
		ServerSocketChannel server = (ServerSocketChannel) key.channel();// 服務端
		try {
			client = server.accept();// 客戶端接入產生一個SocketChannel
			System.out.println("server receive a connet request of client!");
			if (client == null) {
				return;
			}
			client.configureBlocking(false);// 設定客戶端通道為非阻塞
			client.register(selector, SelectionKey.OP_READ);//一般不會主動設定SelectionKey.OP_WRITE，因為緩衝區會一直處於可寫狀態，無限觸發select()
		} catch (Exception e) {
			server.close();
		}
	}

	/**
	 * 處理讀監聽事件
	 * @param key
	 * @throws IOException
	 */
	private static void handleReadEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = (SocketChannel) key.channel();
		ByteBuffer readBuffer = ByteBuffer.allocate(1024);
		client.read(readBuffer);
		byte[] data = readBuffer.array();
		String msg = new String(data).trim();//消除空格
		System.out.println("server receive the client msg:" + msg);
		String outMsg = "I am the server!";
		ByteBuffer writeBuffer = ByteBuffer.wrap(outMsg.getBytes());
		client.write(writeBuffer);
	}

}

package com.xdong.nio.v2.server;

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;

/**
 * v2=執行緒池、單reactor
 * @author xiongchaoqun
 * @date 2018年7月2日
 */
public class NioServer {

	public static void main(String[] args) {
		ServerSocketChannel serverSocketChannel = null;// 宣告服務端Channel
		try {
			serverSocketChannel = ServerSocketChannel.open();// 例項化
			serverSocketChannel.bind(new InetSocketAddress(1234));// 繫結埠
			Selector selector = Selector.open();// 例項化一個Selector
			serverSocketChannel.configureBlocking(false);//設定非阻塞，才能進行下面的register
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// 註冊可接受連線監聽
			while (selector.select() > 0) {
				Iterator<SelectionKey> it = selector.selectedKeys().iterator();
				while (it.hasNext()) {
					SelectionKey key = it.next();
					it.remove();// 如果不移除，那麼下次遍歷還會處理這個selectionKey
					if (key.isAcceptable()) {
						handleAcceptEvent(selector,key);
					} else if (key.isReadable()) {
						new Processor().process(key);//使用執行緒池處理
					}
					Thread.sleep(1000);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 處理客戶端接入事件
	 * 
	 * @param key
	 * @throws IOException
	 */
	private static void handleAcceptEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = null;// 客戶端
		ServerSocketChannel server = (ServerSocketChannel) key.channel();// 服務端
		try {
			client = server.accept();// 客戶端接入產生一個SocketChannel
			System.out.println("server receive a connet request of client!");
			if (client == null) {
				return;
			}
			client.configureBlocking(false);// 設定客戶端通道為非阻塞
			client.register(selector, SelectionKey.OP_READ);//一般不會主動設定SelectionKey.OP_WRITE，因為緩衝區會一直處於可寫狀態，無限觸發select()
		} catch (Exception e) {
			server.close();
		}
	}

	/**
	 * 處理讀監聽事件
	 * @param key
	 * @throws IOException
	 */
	private static void handleReadEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = (SocketChannel) key.channel();
		ByteBuffer readBuffer = ByteBuffer.allocate(1024);
		client.read(readBuffer);
		byte[] data = readBuffer.array();
		String msg = new String(data).trim();//消除空格
		System.out.println("server receive the client msg:" + msg);
		String outMsg = "I am the server!";
		ByteBuffer writeBuffer = ByteBuffer.wrap(outMsg.getBytes());
		client.write(writeBuffer);
	}

}

package com.xdong.nio.v3.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.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * v3=執行緒池+雙reactor(雙Selector)
 * @author xiongchaoqun
 * @date 2018年7月2日
 */
public class NioServer {

	public static void main(String[] args) {
		ServerSocketChannel serverSocketChannel = null;// 宣告服務端Channel
		try {
			serverSocketChannel = ServerSocketChannel.open();// 例項化
			serverSocketChannel.bind(new InetSocketAddress(1234));// 繫結埠
			Selector selector = Selector.open();// 例項化一個Selector
			serverSocketChannel.configureBlocking(false);//設定非阻塞，才能進行下面的register
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// 註冊可接受連線監聽
			
		    int coreNum = 2;
		    Processor[] processors = new Processor[coreNum];
		    for (int i = 0; i < processors.length; i++) {
		    	processors[i] = new Processor();
		    }
		    int acceptNum = 0;
			while (selector.select() > 0) {
				Iterator<SelectionKey> it = selector.selectedKeys().iterator();
				while (it.hasNext()) {
					SelectionKey key = it.next();
					it.remove();// 如果不移除，那麼下次遍歷還會處理這個selectionKey
					if (key.isAcceptable()) {
						acceptNum++;
						SocketChannel channel = null;// 客戶端
						ServerSocketChannel server = (ServerSocketChannel) key.channel();// 服務端
						channel = server.accept();// 客戶端接入產生一個SocketChannel
						System.out.println("server receive a connet request of client!");
						Processor processor = processors[acceptNum%coreNum];
						System.out.println(1);
						processor.addChannel(channel);//將SocketChannel交給另一個Selector去處理
						System.out.println(142);
						processor.wakeup();
					} 
					Thread.sleep(1000);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

package com.xdong.nio.v2.client;

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;

/**
 * v2=執行緒池、單reactor
 * @author xiongchaoqun
 * @date 2018年7月2日
 */
public class NioClient {
	
	public static void main(String[] args) throws Exception{
		SocketChannel socketChannel = null;
		socketChannel = SocketChannel.open();
		Selector selector = Selector.open();
		socketChannel.configureBlocking(false);//設定非阻塞，這樣才能使用Selector
		socketChannel.connect(new InetSocketAddress(1234));//客戶端連線--這裡其實客戶端並沒有完成連線，是在channel.finishConnect();才能完成連線
		socketChannel.register(selector, SelectionKey.OP_CONNECT);//註冊可連線事件
		while (selector.select() > 0) {
			Iterator<SelectionKey>it = selector.selectedKeys().iterator();
			while (it.hasNext()) {
				SelectionKey key = (SelectionKey) it.next();
				it.remove();
				if (key.isConnectable()) {
					handleConnectEvent(selector, key);
				}else if(key.isReadable()) {
					handleReadEvent(selector, key);
				}
				Thread.sleep(1000);
			}
		}
	}
	
	
	public static void handleConnectEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = (SocketChannel) key.channel();
		if (client.isConnectionPending()) {
			client.finishConnect();
		}
		client.configureBlocking(false);//設定通道為非阻塞
		client.write(ByteBuffer.wrap(new String("I want to connet to the server!").getBytes()));//服務端  讀操作會讀到
		client.register(selector, SelectionKey.OP_READ);//註冊可讀時間
	}
	
	public static void handleReadEvent(Selector selector,SelectionKey key) throws IOException {
		SocketChannel client = (SocketChannel) key.channel();
		ByteBuffer buffer = ByteBuffer.allocate(1024);//宣告一個bytebuffer
		client.read(buffer);
		byte[] bytes = buffer.array();
		String getMsg = new String(bytes).trim();
		System.out.println("client receive server msg is "+getMsg);
		client.write(ByteBuffer.wrap(new String("I am a client!").getBytes()));
	}
}

Demo專案程式碼已上傳至我的Git上，有興趣的可以去fork一下。

Java 標準IO框架與NIO框架詳解

在看這篇文章之前，可以先去看看我部落格中另一篇關於同步與非同步、阻塞與非阻塞的理解Java標準IO（BIO） BIO全稱Blocking IO又叫做同步阻塞IO，它存在如下特點：面向流同步阻塞package com.xdong.bio.client; impo

Java中自動裝箱與拆箱詳解

sans 做的 sys 實例代碼而在 byte 裝箱 bsp 在講裝箱與拆箱之前我們要先了解一下這個問題的來源： Java中的類型分為基本類型（Primitive type）和類類型（Class type）兩種：基本類型包括byte型、char型、short型

Java併發程式設計：JMM (Java記憶體模型) 以及與volatile關鍵字詳解

計算機系統的一致性在現代計算機作業系統中，多工處理幾乎是一項必備的功能，因為嵌入了多核處理器，計算機系統真正做到了同一時間執行若干個任務，是名副其實的多核系統。在多核系統中，為了提升CPU與記憶體的互動效率，一般都設定了一層 “快取記憶體區” 作為記憶體與處理器之間的緩衝，使得CPU在運算的過程中直接從快

java的記憶體模型與volatile關鍵字詳解

由於各種硬體及作業系統的記憶體訪問差異，java虛擬機器使用java記憶體模型（java Memory Model，JMM）來規範java對記憶體的訪問。這套模型在jdk 1.2中開始建立，經jdk 1.5的修訂，現已逐步完善起來。什麼是java記憶體模

Java執行緒併發與安全性問題詳解

併發與執行緒安全問題詳解什麼是併發執行緒併發安全問題什麼是併發想要解決執行緒併發安全問題，那首先要弄清楚什麼是併發？ - 執行緒的併發原理： - 我們先舉一個例子，在你做數學題的時候能不能同時背課文，有些同學說可以一心二

java的自動裝箱與拆箱詳解

什麼是自動裝箱拆箱基本資料型別的自動裝箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0開始提供的功能。一般我們要建立一個類的物件例項的時候，我們會這樣： Class a = new Class(parameter); 當我們建立一個

java多執行緒與併發程式設計詳解

一、多執行緒1、作業系統有兩個容易混淆的概念，程序和執行緒。程序：一個計算機程式的執行例項，包含了需要執行的指令；有自己的獨立地址空間，包含程式內容和資料；不同程序的地址空間是互相隔離的；程序擁有各種資源和狀態資訊，包括開啟的檔案、子程序和訊號處理。執行緒：表示程式的執行流程

java基本資料型別與封裝型別詳解(int和Integer區別)

int是java提供的8種原始資料型別之一。 Java為每個原始型別提供了封裝類，Integer是java為int提供的封裝類（即Integer是一個java物件，而int只是一個基本資料型別）。int的預設值為0，而Integer的預設值為null，即Integer可以區

Java連載3-編譯與執行階段詳解&JRE,JDK,JVM關係

·一、 1.JDK下載地址：https://www.oracle.com/technetwork/java/javase/downloads/jdk12-downloads-5295953.html 二、Java的載入與執行 1.Java程式執行包括：（1）編譯階段：檢查Java源程式是否符合Java語法，

java 一款可以與ssm框架完美整合的web報表控件

cnblogs clas tar req pap 整合大型自定義報表環境　　碩正套件運行於客戶端(瀏覽器)，與應用服務器(Application Server)技術無關，所以能完全用於J2EE、　 ASP.Net、php等技術開發的Web應用產品中。　碩正套件部署

超輕量級DI容器框架Google Guice與Spring框架的區別教程詳解及其demo程式碼片段分享

依賴注入，DI（Dependency Injection），它的作用自然不必多說，提及DI容器，例如spring，picoContainer，EJB容器等等，近日，google誕生了更輕巧的DI容器……Guice! 廢話不多講了，先看看Guice是如何實現注入的吧。定

Python爬蟲從入門到放棄（十三）之 Scrapy框架的命令行詳解

directory xpath idf 成了 spider i386 名稱 4.2 不同的這篇文章主要是對的scrapy命令行使用的一個介紹創建爬蟲項目 scrapy startproject 項目名例子如下： localhost:spider zhaofan$ sc

Ehcache緩存框架與 Shiro 框架出現出現驗證錯誤 && Tomcat 緩存清除的問題

輸入後臺一起 logs 並且我想。。 ehcache 清除當一個項目使用久了以後就會出現各種問題，下面是我遇到的一個權限驗證錯誤的問題我的項目是 Ehcache 結合 Shiro 一起使用的，項目用用久了出現 Token驗證錯誤，Co

MVC框架與MTC框架

one func none int art lose body UNC set 3、WEB框架 MVC Model View Controller 數據庫模板文件業務處理 MTV Model Template

Sping框架中的註解詳解

例子上下 troy getbean 用戶id 查找 oge 數據庫配置傳統的Spring做法是使用.xml文件來對bean進行註入或者是配置aop、事物，這麽做有兩個缺點：1、如果所有的內容都配置在.xml文件中，那麽.xml文件將會十分龐大；如果按需求分開.xml文

Hibernate框架環境搭建（詳解）

obj 模型 junit demo 半成品 src 數據表 mys 種類具體說hibernate框架的項目搭建之前，首先說一下什麽是框架。。。框架可以理解成一個半成品的項目，它封裝了一些功能，我麽需要掌握的是如何駕馭這些功能，不需要操心它是怎麽實現的。其實他

Java內部類與final關鍵字詳解

修飾 tor oca 修飾符 key eight 標識 cal ner 閱讀目錄一、內部類的幾種創建方法：二、神馬是內部類？三、最後來說說final關鍵字：回到頂部一、內部類的幾種創建方法： 1、成員內部類 1 2 3 4 5 6 cl

Python爬蟲從入門到成妖之3-----Scrapy框架的命令行詳解

參數成了 openssl 入門文件中 crawler 1.0 使用 lob 創建爬蟲項目 scrapy startproject 項目名例子如下： E:\crawler>scrapy startproject test1 New Scrapy pro

區別輕量級框架與重量級框架

總述:輕量級框架和重量級框架解決問題的側重點是不同的。輕量級框架側重於減小開發的複雜度，相應的它的處理能力便有所減弱（如事務功能弱、不具備分散式處理能力），比較適用於開發中小型企業應用。採用輕量框架一方面因為儘可能的採用基於POJOs的方法進行開發，使應用不依賴於任何容器，這可以提高開發除錯效

#Java怎麼學？2018最新Java學習路線，技術要求與專案推薦詳解！

一基礎篇很多人認為，java的基礎應該是C語言，這個不可否認，但是也不能說完全正確，因為兩個語言技術的內涵是不一樣的，C語言是面向語言程式設計而java語言是面向物件程式設計，打個比喻，C語言大多數是做系統應用，而java是做企業級應用的。所以，學Java不一定要學C，Java簡化了C，而在

Java 標準IO框架與NIO框架詳解

Java標準IO（BIO）

Java NIO框架

相關推薦