Java如何實作原生socket通訊機制的原理詳解

本篇文章主要介紹了JAVA中實現原生的 socket 通訊機制原理，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。一起跟著小編過來看看吧

本文介紹了JAVA中實作原生的socket 通訊機制原理，分享給大家，具體如下：

##目前環境

jdk == 1.8

知識點

• socket 的連線處理

• #IO 輸入、輸出流的處理

• 請求資料格式處理

• 請求模型最佳化

場景

今天，跟大家聊聊JAVA 中的socket 通訊問題。這裡採用最簡單的一請求一回應模型為例，假設我們現在需要向 baidu 網站進行通訊。我們用 JAVA 原生的 socket 該如何實現。

建立socket 連線

首先，我們需要建立socket 連線（核心程式碼）

import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
    
// 初始化 socket
Socket socket = new Socket();
// 初始化远程连接地址
SocketAddress remote = new InetSocketAddress(host, port);
// 建立连接
socket.connect(remote);

處理socket 輸入輸出流

成功建立socket 連線後，我們就能得到它的輸入輸出流，而通訊的本質是對輸入輸出流的處理。透過輸入流，讀取網路連線上傳來的數據，透過輸出流，將本地的數據傳出給遠端。

socket 連線實際上與處理檔案流有點類似，都是在進行 IO 操作。

取得輸入、輸出流程程式碼如下：

// 输入流
InputStream in = socket.getInputStream();
// 输出流
OutputStream out = socket.getOutputStream();

關於IO 流的處理，我們一般會用對應的包裝類別來處理IO 流，如果直接處理的話，我們需要對byte[] 進行操作，而這是相對比較繁瑣的。如果採用包裝類，我們可以直接以string、int等類型處理，簡化了 IO 位元組運算。

下面以

BufferedReader 與 PrintWriter 作為輸入輸出的包裝類別進行處理。

// 获取 socket 输入流
private BufferedReader getReader(Socket socket) throws IOException {
  InputStream in = socket.getInputStream();
  return new BufferedReader(new InputStreamReader(in));
}

// 获取 socket 输出流
private PrintWriter getWriter(Socket socket) throws IOException {
  OutputStream out = socket.getOutputStream();
  return new PrintWriter(new OutputStreamWriter(out));
}

資料請求與回應

有了socket 連線、IO 輸入輸出流，就該向發送請求數據，以及取得請求的回應結果。

因為有了 IO 包裝類別的支持，我們可以直接以字串的格式進行傳輸，由包裝類別幫我們將資料裝換成對應的位元組流。

因為我們與 baidu 網站進行的是 HTTP 訪問，所有我們不需要額外定義輸出格式。採用標準的 HTTP 傳輸格式，就能進行請求回應了（某些特定的 RPC 框架，可能會有自訂的通訊格式）。

請求的資料內容處理如下：

public class HttpUtil {

  public static String compositeRequest(String host){

    return "GET / HTTP/1.1\r\n" +
        "Host: " + host + "\r\n" +
        "User-Agent: curl/7.43.0\r\n" +
        "Accept: */*\r\n\r\n";
  }
  
}

傳送請求資料代碼如下：

##

// 发起请求
PrintWriter writer = getWriter(socket);
writer.write(HttpUtil.compositeRequest(host));
writer.flush();
接收响应数据代码如下：

// 读取响应
String msg;
BufferedReader reader = getReader(socket);
while ((msg = reader.readLine()) != null){
  System.out.println(msg);
}

至此，講完了原生socket 下的創建連線、發送請求與接收回應的所有核心程式碼。

完整程式碼如下：

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import com.test.network.util.HttpUtil;

public class SocketHttpClient {

  public void start(String host, int port) {

    // 初始化 socket
    Socket socket = new Socket();

    try {
      // 设置 socket 连接
      SocketAddress remote = new InetSocketAddress(host, port);
      socket.setSoTimeout(5000);
      socket.connect(remote);

      // 发起请求
      PrintWriter writer = getWriter(socket);
      System.out.println(HttpUtil.compositeRequest(host));
      writer.write(HttpUtil.compositeRequest(host));
      writer.flush();

      // 读取响应
      String msg;
      BufferedReader reader = getReader(socket);
      while ((msg = reader.readLine()) != null){
        System.out.println(msg);
      }

    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        socket.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

  }

  private BufferedReader getReader(Socket socket) throws IOException {
    InputStream in = socket.getInputStream();
    return new BufferedReader(new InputStreamReader(in));
  }

  private PrintWriter getWriter(Socket socket) throws IOException {
    OutputStream out = socket.getOutputStream();
    return new PrintWriter(new OutputStreamWriter(out));
  }

}

下面，我們透過實例化一個客戶端，來展示 socket 通訊的結果。

public class Application {

  public static void main(String[] args) {

    new SocketHttpClient().start("www.baidu.com", 80);

  }
}

結果輸出：

 

#請求模型最佳化

這種方式，雖然實作功能沒什麼問題。但我們細看，發現在 IO 寫入與讀取過程，是發生了 IO 阻塞的情況。即：

// 会发生 IO 阻塞
writer.write(HttpUtil.compositeRequest(host));
reader.readLine();

所以如果要同時請求10個不同的站點，如下：

public class SingleThreadApplication {

  public static void main(String[] args) {

    // HttpConstant.HOSTS 为 站点集合
    for (String host: HttpConstant.HOSTS) {

      new SocketHttpClient().start(host, HttpConstant.PORT);

    }

  }
}

它一定是第一個請求回應結束後，才會發起下一個站點處理。

這在服務端更明顯，雖然這裡的程式碼是客戶端連接，但是具體的操作和服務端是差不多的。請求只能一個個串列處理，這在回應時間上絕對不能達標。

多執行緒處理
有人覺得這根本不是問題，JAVA 是多執行緒的程式語言。對於這種情況，採用多執行緒的模型再適合不過。

public class MultiThreadApplication {

  public static void main(String[] args) {

    for (final String host: HttpConstant.HOSTS) {

      Thread t = new Thread(new Runnable() {
        public void run() {
          new SocketHttpClient().start(host, HttpConstant.PORT);
        }
      });

      t.start();

    }
  }
}

這種方式一開始看起來挺有用的，但並發量一大，應用會起很多的執行緒。都知道，在伺服器上，每個執行緒實際上都會佔據一個檔案句柄。而伺服器上的句柄數是有限的，而且大量的線程，造成的線程間切換的消耗也會相當的大。所以這種方式在並發量大的場景下，一定是承載不住的。

多執行緒 + 執行緒池 處理
#既然執行緒太多不行，那我們控制一下執行緒建立的數目不就行了。只啟動固定的執行緒數來進行 socket 處理，既利用了多執行緒的處理，也控制了系統的資源消耗。

public class ThreadPoolApplication {

  public static void main(String[] args) {

    ExecutorService executorService = Executors.newFixedThreadPool(8);

    for (final String host: HttpConstant.HOSTS) {

      Thread t = new Thread(new Runnable() {
        public void run() {
          new SocketHttpClient().start(host, HttpConstant.PORT);
        }
      });

      executorService.submit(t);
      new SocketHttpClient().start(host, HttpConstant.PORT);

    }

  }
}

關於啟動的執行緒數，一般 CPU 密集型會設定在 N+1（N為CPU核數），IO 密集型設定在 2N + 1。

這種方式，看起來是最優的了。那有沒有更好的呢，如果一個線程能同時處理多個 socket 連接，並且在每個 socket 輸入輸出數據沒有準備好的情況下，不進行阻塞，那是不是更優呢。這種技術叫做「IO多路復用」。在 JAVA 的 nio 包中，提供了相應的實作。

以上是Java如何實作原生socket通訊機制的原理詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！