基於BIO的Java Socket通信詳解

BIO，即阻塞IO，在基於Socket的消息通信過程中，Socket服務端向外部提供服務，而Socket客戶端可以建立到Socket服務端的連接，進而發送請求數據，然後等待Socket服務端處理，並返回處理結果（響應）。
基於BIO的通信，Socket服務端會發生阻塞，即在監聽過程中每次accept到一個客戶端的Socket連接，就要處理這個請求，而此時其他連接過來的客戶端只能阻塞等待。可見，這種模式下Socket服務端的處理能力是非常有限的，客戶端也只能等待，直到服務端空閒時進行請求的處理。

BIO通信實現

下面基於BIO模式，來實現一個簡單的Socket服務端與Socket客戶端進行通信的邏輯，對這種通信方式有一個感性的認識。具體邏輯描述如下：
1、Socket客戶端連接到Socket服務端，並發送數據“I am the client N.”；
2、Socket服務端，監聽服務端口，並接收客戶端請求數據，如果請求數據以“I am the client”開頭，則響應客戶端“I am the server, and you are the Nth client.”；

Socket服務端實現，代碼如下所示：

 package org.shirdrn.java.communications.bio; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; /** * 基於BIO的Socket服務器端* * @author shirdrn */ public class SimpleBioTcpServer extends Thread { /** 服務端口號*/ private int port = 8888; /** 為客戶端分配編號*/ private static int sequence = 0; public SimpleBioTcpServer(int port) { this.port = port; } @Override public void run() { Socket socket = null; try { ServerSocket serverSocket = new ServerSocket(this.port); while(true) { socket = serverSocket.accept(); // 監聽this.handleMessage(socket); // 處理一個連接過來的客戶端請求} } catch (IOException e) { e.printStackTrace(); } } /** * 處理一個客戶端socket連接* @param socket 客戶端socket * @throws IOException */ private void handleMessage(Socket socket) throws IOException { InputStream in = socket.getInputStream(); // 流：客戶端->服務端（讀） OutputStream out = socket.getOutputStream(); // 流：服務端->客戶端（寫） int receiveBytes; byte[] receiveBuffer = new byte[128]; String clientMessage = ""; if((receiveBytes=in.read(receiveBuffer))!=-1) { clientMessage = new String(receiveBuffer, 0, receiveBytes); if(clientMessage.startsWith("I am the client")) { String serverResponseWords = "I am the server, and you are the " + (++sequence) + "th client."; out.write(serverResponseWords.getBytes()); } } out.flush(); System.out.println("Server: receives clientMessage->" + clientMessage); } public static void main(String[] args) { SimpleBioTcpServer server = new SimpleBioTcpServer(1983); server.start(); } }

上述實現，沒有進行複雜的異常處理。

Socket客戶端實現，代碼如下所示：

 package org.shirdrn.java.communications.bio; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.net.UnknownHostException; import java.util.Date; /** * 基於BIO的Socket客戶端* * @author shirdrn */ public class SimpleBioTcpClient { private String ipAddress; private int port; private static int pos = 0; public SimpleBioTcpClient() {} public SimpleBioTcpClient(String ipAddress, int port) { this.ipAddress = ipAddress; this.port = port; } /** * 連接Socket服務端，並模擬發送請求數據* @param data 請求數據*/ public void send(byte[] data) { Socket socket = null; OutputStream out = null; InputStream in = null; try { socket = new Socket(this.ipAddress, this.port); // 連接// 發送請求out = socket.getOutputStream(); out.write(data); out.flush(); // 接收響應in = socket.getInputStream(); int totalBytes = 0; int receiveBytes = 0; byte[] receiveBuffer = new byte[128]; if((receiveBytes=in.read(receiveBuffer))!=-1) { totalBytes += receiveBytes; } String serverMessage = new String(receiveBuffer, 0, receiveBytes); System.out.println("Client: receives serverMessage->" + serverMessage); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { try { // 發送請求並接收到響應，通信完成，關閉連接out.close(); in.close(); socket.close(); } catch (IOException e) { e.printStackTrace(); } } } public static void main(String[] args) { int n = 1; StringBuffer data = new StringBuffer(); Date start = new Date(); for(int i=0; i<n; i++) { data.delete(0, data.length()); data.append("I am the client ").append(++pos).append("."); SimpleBioTcpClient client = new SimpleBioTcpClient("localhost", 1983); client.send(data.toString().getBytes()); } Date end = new Date(); long cost = end.getTime() - start.getTime(); System.out.println(n + " requests cost " + cost + " ms."); } }

首先啟動Socket服務端進程SimpleBioTcpServer，然後再運行Socket客戶端SimpleBioTcpClient。可以看到，服務端接收到請求數據，然後響應客戶端，客戶端接收到了服務端的響應數據。

上述實現中，對於Socket客戶端和服務端都是一次寫入，並一次讀出，而在實際中如果每次通信過程中數據量特別大的話，服務器端是不可能接受的，可以在確定客戶端請求數據字節數的情況，循環來讀取並進行處理。

另外，對於上述實現中流沒有進行裝飾（Wrapped）處理，在實際中會有性能的損失，如不能緩衝等。

對於Socket服務端接收數據，如果可以使多次循環讀取到的字節數據通過一個可變長的字節緩衝區來存儲，就能方便多了，可是使用ByteArrayOutputStream，例如：

 ByteArrayOutputStream data = new ByteArrayOutputStream(); data.write(receiveBuffer, totalBytes , totalBytes + receiveBytes);

BIO通信測試

下面測試一下大量請求的場景下，Socket服務端處理的效率。

第一種方式：通過for循環來啟動5000個Socket客戶端，發送請求，代碼如下所示：

 public static void main(String[] args) { int n = 5000; StringBuffer data = new StringBuffer(); Date start = new Date(); for(int i=0; i<n; i++) { data.delete(0, data.length()); data.append("I am the client ").append(++pos).append("."); SimpleBioTcpClient client = new SimpleBioTcpClient("localhost", 1983); client.send(data.toString().getBytes()); } Date end = new Date(); long cost = end.getTime() - start.getTime(); System.out.println(n + " requests cost " + cost + " ms."); }

經過測試，大約需要9864ms，大概接近10s。

第二種方式：通過啟動5000個獨立的客戶端線程，同時請求，服務端進行計數：

 package org.shirdrn.java.communications.bio; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; import java.net.UnknownHostException; import java.util.Date; /** * 基於BIO的Socket通信測試* * @author shirdrn */ public class SimpleBioTcpTest { static int threadCount = 5000; /** * 基於BIO的Socket服務端進程* * @author shirdrn */ static class SocketServer extends Thread { /** 服務端口號*/ private int port = 8888; /** 為客戶端分配編號*/ private static int sequence = 0; public SocketServer(int port) { this.port = port; } @Override public void run() { Socket socket = null; int counter = 0; try { ServerSocket serverSocket = new ServerSocket(this.port); boolean flag = false; Date start = null; while(true) { socket = serverSocket.accept(); // 監聽// 有請求到來才開始計時if(!flag) { start = new Date(); flag = true; } this.handleMessage(socket); // 處理一個連接過來的客戶端請求if(++counter==threadCount) { Date end = new Date(); long last = end.getTime() - start.getTime(); System.out.println(threadCount + " requests cost " + last + " ms."); } } } catch (IOException e) { e.printStackTrace(); } } /** * 處理一個客戶端socket連接* @param socket 客戶端socket * @throws IOException */ private void handleMessage(Socket socket) throws IOException { InputStream in = socket.getInputStream(); // 流：客戶端->服務端（讀） OutputStream out = socket.getOutputStream(); // 流：服務端->客戶端（寫） int receiveBytes; byte[] receiveBuffer = new byte[128]; String clientMessage = ""; if((receiveBytes=in.read(receiveBuffer))!=-1) { clientMessage = new String(receiveBuffer, 0, receiveBytes); if(clientMessage.startsWith("I am the client")) { String serverResponseWords = "I am the server, and you are the " + (++sequence) + "th client."; out.write(serverResponseWords.getBytes()); } } out.flush(); System.out.println("Server: receives clientMessage->" + clientMessage); } } /** * 基於BIO的Socket客戶端線程* * @author shirdrn */ static class SocketClient implements Runnable { private String ipAddress; private int port; /** 待發送的請求數據*/ private String data; public SocketClient(String ipAddress, int port) { this.ipAddress = ipAddress; this.port = port; } @Override public void run() { this.send(); } /** * 連接Socket服務端，並模擬發送請求數據*/ public void send() { Socket socket = null; OutputStream out = null; InputStream in = null; try { socket = new Socket(this.ipAddress, this.port); // 連接// 發送請求out = socket.getOutputStream(); out.write(data.getBytes()); out.flush(); // 接收響應in = socket.getInputStream(); int totalBytes = 0; int receiveBytes = 0; byte[] receiveBuffer = new byte[128]; if((receiveBytes=in.read(receiveBuffer))!=-1) { totalBytes += receiveBytes; } String serverMessage = new String(receiveBuffer, 0, receiveBytes); System.out.println("Client: receives serverMessage->" + serverMessage); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { try { // 發送請求並接收到響應，通信完成，關閉連接out.close(); in.close(); socket.close(); } catch (IOException e) { e.printStackTrace(); } } } public void setData(String data) { this.data = data; } } public static void main(String[] args) throws Exception { SocketServer server = new SocketServer(1983); server.start(); Thread.sleep(3000); for(int i=0; i<threadCount; i++) { SocketClient client = new SocketClient("localhost", 1983); client.setData("I am the client " + (i+1) + "."); new Thread(client).start(); Thread.sleep(0, 1); } } }

經過測試，大約需要7110ms，大概接近7s，沒有太大提高。

BIO通信改進

通過上面的測試我們可以發現，在Socket服務端對來自客戶端的請求進行處理時，會發生阻塞，嚴重地影響了能夠並發處理請求的效率。實際上，在Socket服務端接收來自客戶端連接能力的範圍內，可以將接收請求獨立出來，從而在將處理請求獨立粗話來，通過一個請求一個線程處理的方式來解決上述問題。這樣，服務端是多處理線程對應客戶端多請求，處理效率有一定程度的提高。

下面，通過單線程接收請求，然後委派線程池進行多線程並發處理請求：

 /** * 基於BIO的Socket服務端進程* * @author shirdrn */ static class SocketServer extends Thread { /** 服務端口號*/ private int port = 8888; /** 為客戶端分配編號*/ private static int sequence = 0; /** 處理客戶端請求的線程池*/ private ExecutorService pool; public SocketServer(int port, int poolSize) { this.port = port; this.pool = Executors.newFixedThreadPool(poolSize); } @Override public void run() { Socket socket = null; int counter = 0; try { ServerSocket serverSocket = new ServerSocket(this.port); boolean flag = false; Date start = null; while(true) { socket = serverSocket.accept(); // 監聽// 有請求到來才開始計時if(!flag) { start = new Date(); flag = true; } // 將客戶端請求放入線程池處理pool.execute(new RequestHandler(socket)); if(++counter==threadCount) { Date end = new Date(); long last = end.getTime() - start.getTime(); System.out.println(threadCount + " requests cost " + last + " ms."); } } } catch (IOException e) { e.printStackTrace(); } } /** * 客戶端請求處理線程類* * @author shirdrn */ class RequestHandler implements Runnable { private Socket socket; public RequestHandler(Socket socket) { this.socket = socket; } @Override public void run() { try { InputStream in = socket.getInputStream(); // 流：客戶端->服務端（讀） OutputStream out = socket.getOutputStream(); // 流：服務端->客戶端（寫） int receiveBytes; byte[] receiveBuffer = new byte[128]; String clientMessage = ""; if((receiveBytes=in.read(receiveBuffer))!=-1) { clientMessage = new String(receiveBuffer, 0, receiveBytes); if(clientMessage.startsWith("I am the client")) { String serverResponseWords = "I am the server, and you are the " + (++sequence) + "th client."; out.write(serverResponseWords.getBytes()); } } out.flush(); System.out.println("Server: receives clientMessage->" + clientMessage); } catch (IOException e) { e.printStackTrace(); } } } }

可見，這種改進方式增強服務端處理請求的並發度，但是每一個請求都要由一個線程去處理，大量請求造成服務端啟動大量進程進行處理，也是比較佔用服務端資源的。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持武林網。