摘要：采用標準的傳輸格式，就能進行請求響應了某些特定的框架，可能會有自定義的通信格式。對于這種情況，采用多線程的模型再合適不過。只啟動固定的線程數來進行處理，既利用了多線程的處理，又控制了系統(tǒng)的資源消耗。在的包中，提供了相應的實現(xiàn)。

摘要：本文屬于原創(chuàng)，歡迎轉載，轉載請保留出處：https://github.com/jasonGeng88/blog

jdk == 1.8

socket 的連接處理

IO 輸入、輸出流的處理

請求數據格式處理

請求模型優(yōu)化

今天，和大家聊一下 JAVA 中的 socket 通信問題。這里采用最簡單的一請求一響應模型為例，假設我們現(xiàn)在需要向 baidu 站點進行通信。我們用 JAVA 原生的 socket 該如何實現(xiàn)。

首先，我們需要建立 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 連接實際與處理文件流有點類似，都是在進行 IO 操作。

獲取輸入、輸出流代碼如下：

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

關于 IO 流的處理，我們一般會用相應的包裝類來處理 IO 流，如果直接處理的話，我們需要對 byte[] 進行操作，而這是相對比較繁瑣的。如果采用包裝類，我們可以直接以string、int等類型進行處理，簡化了 IO 字節(jié)操作。

下面以 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 輸入輸出流，下面就該向發(fā)送請求數據，以及獲取請求的響應結果。

因為有了 IO 包裝類的支持，我們可以直接以字符串的格式進行傳輸，由包裝類幫我們將數據裝換成相應的字節(jié)流。

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

請求的數據內容處理如下：

public class HttpUtil {

    public static String compositeRequest(String host){

        return "GET / HTTP/1.1
" +
                "Host: " + host + "
" +
                "User-Agent: curl/7.43.0
" +
                "Accept: */*

";
    }
    
}

發(fā)送請求數據代碼如下：

// 發(fā)起請求
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 下的創(chuàng)建連接、發(fā)送請求與接收響應的所有核心代碼。

完整代碼如下：

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);

            // 發(fā)起請求
            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);

    }
}

結果輸出：

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

// 會發(fā)生 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);

        }

    }
}

它一定是第一個請求響應結束后，才會發(fā)起下一個站點處理。

這在服務端更明顯，雖然這里的代碼是客戶端連接，但是具體的操作和服務端是差不多的。請求只能一個個串行處理，這在響應時間上肯定不能達標。

多線程處理

有人覺得這根本不是問題，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();

        }
    }
}

這種方式起初看起來挺有用的，但并發(fā)量一大，應用會起很多的線程。都知道，在服務器上，每一個線程實際都會占據一個文件句柄。而服務器上的句柄數是有限的，而且大量的線程，造成的線程間切換的消耗也會相當的大。所以這種方式在并發(fā)量大的場景下，一定是承載不住的。

多線程 + 線程池 處理

既然線程太多不行，那我們控制一下線程創(chuàng)建的數目不就行了。只啟動固定的線程數來進行 socket 處理，既利用了多線程的處理，又控制了系統(tǒng)的資源消耗。

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。

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

JAVA 中是如何實現(xiàn) IO多路復用

Netty 下的實現(xiàn)異步請求的