C++多線程網絡編程：助力高并發服務器性能提升

作者：深度Linux 2025-07-07 00:00:00

減少鎖的使用是提高性能的關鍵策略之一。在前面的代碼中，對users的訪問使用了互斥鎖usersMutex，這在高并發情況下可能會成為性能瓶頸。可以考慮使用無鎖數據結構，如前面介紹的無鎖鏈表或無鎖哈希表，來替換std::unordered_map，以減少鎖競爭，提高并發性能。

在數字化時代，高并發是互聯網服務的常態 —— 電商購物節的海量訂單、社交網絡的熱門話題討論、在線游戲的萬人同服，都需要強大的并發處理能力。高并發服務器作為核心支柱，其性能與穩定性直接影響用戶體驗和業務成敗。C++ 憑借卓越性能、高效執行效率和對系統資源的精準掌控，在高并發服務器開發中地位關鍵。多線程網絡編程更是其核心優勢，能充分利用多核 CPU 算力，讓服務器同時處理多個任務，大幅提升并發處理能力和響應速度。

想象一下，在一場激烈的電商大促中，C++ 多線程網絡編程驅動的服務器如同一位不知疲倦的超級英雄，輕松應對數百萬用戶同時下單的請求，快速準確地處理每一筆交易，讓購物車秒變快遞盒，讓用戶暢享絲滑的購物體驗。在這篇文章中，我們將一同深入 C++ 多線程網絡編程的奇妙世界，從基礎概念到高級技巧，從理論知識到實戰演練，揭開高并發服務器開發的神秘面紗，為你打造一把開啟高性能編程大門的鑰匙。

Part1.C++ 多線程編程

1.1線程和進程是什么？

線程，作為操作系統中一個至關重要的概念，是程序執行流的最小單元，也被稱為輕量級進程。如果把進程看作是一個正在運行的工廠，那么線程就是工廠里的各個生產線，每個生產線都可以獨立運作，同時又共享著工廠的資源，如場地、設備等。線程自己基本不擁有系統資源，僅持有一些在運行中必不可少的資源，像程序計數器、一組寄存器和棧，但它能夠與同屬一個進程的其他線程共享進程所擁有的全部資源。

進程是操作系統進行資源分配和調度的獨立單位，擁有獨立的地址空間、代碼和數據空間。而線程則是進程中的實際運作單位，是 CPU 調度和分派的基本單位。一個進程可以包含多個線程，這些線程共享進程的資源，使得它們之間的通信和數據共享更加高效，但也帶來了線程安全的問題。就好比一個辦公室里有多個員工（線程），他們共享辦公室的辦公用品（進程資源），如果多個員工同時爭搶使用同一臺打印機（共享資源），就可能出現混亂，這就需要一些規則（同步機制）來協調。

在 Linux 系統中，我們可以使用 fork () 函數來創建新的進程。fork () 函數的作用是復制當前進程，生成一個子進程。這個子進程幾乎是父進程的一個副本，它擁有與父進程相同的代碼、數據和文件描述符等。

fork () 函數的原理并不復雜。當父進程調用 fork () 時，操作系統會為子進程分配一個新的進程控制塊（PCB），用于管理子進程的相關信息。子進程會繼承父進程的大部分資源，包括內存空間的映射（但有寫時復制機制，后面會詳細介紹）、打開的文件描述符等。

fork () 函數有一個獨特的返回值特性：在父進程中，它返回子進程的進程 ID（PID）；而在子進程中，它返回 0。通過這個返回值，我們可以區分當前是父進程還是子進程在執行，從而讓它們執行不同的代碼邏輯。下面是一個簡單的代碼示例：

#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid;

    // 調用fork()創建子進程
    pid = fork();

    if (pid < 0) {
        // fork()失敗
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子進程
        printf("I am the child process, my PID is %d, my parent's PID is %d\n", getpid(), getppid());
    } else {
        // 父進程
        printf("I am the parent process, my PID is %d, my child's PID is %d\n", getpid(), pid);
    }

    return 0;
}

運行這段代碼，你會看到父進程和子進程分別輸出不同的信息，證明它們是獨立運行的。

在多核處理器的環境下，多線程編程能夠充分發揮硬件的并行處理能力，極大地提高程序的執行效率。比如，在一個圖像編輯軟件中，一個線程可以負責顯示圖像，另一個線程可以同時進行圖像的處理，這樣用戶就能感受到更流暢的操作體驗。

1.2 C++ 線程庫初體驗

從 C++11 開始，標準庫引入了<thread>頭文件，為我們提供了方便的線程相關類和函數，使得編寫跨平臺的多線程程序變得更加容易。要創建一個線程，我們可以使用std::thread類。這個類的構造函數接受一個可調用對象，比如普通函數、lambda 表達式或者成員函數，作為線程執行的入口點。

下面是一個簡單的示例，展示了如何創建和啟動一個線程：

#include <iostream>
#include <thread>

// 普通函數，作為線程執行的任務
void printHello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 創建線程對象，傳入printHello函數
    std::thread t(printHello);

    // 主線程繼續執行
    std::cout << "Hello from main!" << std::endl;

    // 等待子線程完成
    t.join();

    return 0;
}

在這個例子中，我們首先定義了一個printHello函數，它將在新線程中執行。然后，在main函數中，我們創建了一個std::thread對象t，并將printHello函數作為參數傳遞給它，這就啟動了一個新線程。主線程會繼續執行后續的代碼，輸出Hello from main!。最后，通過調用t.join()，主線程會阻塞，等待子線程執行完畢，確保程序的正常結束。

除了普通函數，我們還可以使用 lambda 表達式來創建線程，讓代碼更加簡潔和靈活：

#include <iostream>
#include <thread>

int main() {
    // 使用lambda表達式創建線程
    std::thread t([]() {
        std::cout << "Hello from thread created by lambda!" << std::endl;
    });

    std::cout << "Hello from main!" << std::endl;

    t.join();

    return 0;
}

在這個示例中，我們直接在std::thread的構造函數中傳入了一個 lambda 表達式，這個表達式定義了線程要執行的任務；通過這兩個簡單的示例，我們對 C++ 線程庫的基本使用有了初步的了解。創建和啟動線程是多線程編程的基礎，后續我們還會深入探討線程的同步、通信以及更高級的應用場景。

Part2.網絡編程基礎

2.1套接字（Socket）編程詳解

套接字（Socket）堪稱網絡編程領域中最為基礎且關鍵的概念，它是一種抽象的數據結構，為網絡應用程序之間提供了至關重要的通信接口。從本質上講，套接字就像是網絡通信中的一個端點，承擔著發送和接收數據的重要職責，使得運行在不同機器上的應用程序能夠實現信息的交換，進而達成各種網絡功能。

套接字主要分為兩種類型，分別是基于 TCP 協議的流式套接字（SOCK_STREAM）和基于 UDP 協議的數據報套接字（SOCK_DGRAM）。TCP 套接字以其可靠的連接特性著稱，它能夠確保數據的有序傳輸，并且通過確認機制和重傳機制來保證數據的完整性，就如同一位嚴謹的快遞員，確保每個包裹都能準確無誤地送達目的地；而 UDP 套接字則提供了無連接的服務，它具有傳輸速度快、效率高的優勢，不過不保證數據包的到達順序，甚至可能會出現數據包丟失的情況，類似于普通郵件的投遞，雖然速度較快，但不能完全保證郵件的送達。

圖片

基于 TCP 協議的客戶端和服務器：

服務端和客戶端初始化 socket，得到文件描述符；
服務端調用 bind，綁定 IP 地址和端口；
服務端調用 listen，進行監聽；
服務端調用 accept，等待客戶端連接；
客戶端調用 connect，向服務器端的地址和端口發起連接請求；
服務端 accept 返回用于傳輸的 socket的文件描述符；
客戶端調用 write 寫入數據；服務端調用 read 讀取數據；
客戶端斷開連接時，會調用 close，那么服務端 read 讀取數據的時候，就會讀取到了 EOF，待處理完數據后，服務端調用 close，表示連接關閉。

這里需要注意的是，服務端調用 accept 時，連接成功了會返回一個已完成連接的 socket，后續用來傳輸數據；所以，監聽的 socket 和真正用來傳送數據的 socket，是「兩個」 socket，一個叫作監聽 socket，一個叫作已完成連接 socket；成功連接建立之后，雙方開始通過 read 和 write 函數來讀寫數據，就像往一個文件流里面寫東西一樣。

在 C++ 中，進行套接字編程時，常用的頭文件在 Unix-like 系統（包括 Linux 和 macOS）上是<sys/socket.h>、<netinet/in.h>、<arpa/inet.h>等，而在 Windows 系統上則需要使用<winsock2.h>頭文件，并且還需要進行特定的初始化操作。下面通過一個簡單的服務器和客戶端示例代碼，來詳細說明如何在 C++ 中使用套接字進行網絡通信。

服務器端代碼：

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

#define PORT 8080

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};

    // 創建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 綁定套接字
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *) &address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 監聽連接
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 接受連接
    if ((new_socket = accept(server_fd, (struct sockaddr *) &address, (socklen_t *) &addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    // 接收數據
    int valread = read(new_socket, buffer, 1024);
    std::cout << "Received: " << buffer << std::endl;

    // 發送數據
    const char *response = "Hello from server";
    send(new_socket, response, strlen(response), 0);
    std::cout << "Response sent" << std::endl;

    // 關閉套接字
    close(new_socket);
    close(server_fd);

    return 0;
}

在這段服務器端代碼中，首先使用socket函數創建了一個套接字，其中AF_INET表示使用 IPv4 協議，SOCK_STREAM表示使用 TCP 協議。接著，通過setsockopt函數設置套接字選項，允許地址和端口的重用，以避免端口被占用的問題。然后，將套接字綁定到指定的 IP 地址（INADDR_ANY表示接受所有網卡的連接）和端口上。

使用listen函數將套接字設置為監聽模式，等待客戶端的連接請求，參數3表示允許的最大連接數。當有客戶端連接時，accept函數會從已連接隊列中提取第一個連接請求，并返回一個新的套接字new_socket，用于與客戶端進行通信。之后，通過read函數接收客戶端發送的數據，再使用send函數向客戶端發送響應數據。最后，關閉與客戶端通信的套接字new_socket以及服務器監聽的套接字server_fd。

客戶端代碼：

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>

#define PORT 8080

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // 創建套接字
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 將地址轉換成二進制格式
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address/ Address not supported" << std::endl;
        return -1;
    }

    // 連接到服務器
    if (connect(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection Failed" << std::endl;
        return -1;
    }

    // 發送數據
    const char *message = "Hello from client";
    send(sock, message, strlen(message), 0);
    std::cout << "Message sent" << std::endl;

    // 接收數據
    int valread = read(sock, buffer, 1024);
    std::cout << "Received: " << buffer << std::endl;

    // 關閉套接字
    close(sock);

    return 0;
}

客戶端代碼同樣先使用socket函數創建套接字，然后設置服務器的地址和端口信息。通過inet_pton函數將 IP 地址字符串轉換為二進制格式，以便套接字能夠正確識別。接著，使用connect函數連接到服務器。連接成功后，通過send函數向服務器發送數據，再使用read函數接收服務器返回的響應數據。最后，關閉套接字。

通過這兩個示例代碼，我們可以清晰地看到在 C++ 中使用套接字進行 TCP 網絡通信的基本流程，包括套接字的創建、綁定、監聽、連接以及數據的發送和接收等操作。在實際開發中，還需要注意錯誤處理，確保程序的穩定性和健壯性。

2.2網絡協議與數據傳輸

在網絡通信的廣袤領域中，常見的網絡協議猶如交通規則一般，規范著數據的傳輸方式和流程，其中 TCP/IP 和 UDP/IP 協議占據著舉足輕重的地位。

TCP/IP 協議是網絡通信的基石，它實際上是一個協議族，其中 TCP（傳輸控制協議）負責數據的可靠傳輸，通過三次握手建立連接，保證數據的有序傳輸，并利用確認機制和重傳機制來確保數據的完整性。就好比在一場重要的文件傳輸任務中，TCP 協議會像一位認真負責的管家，確保每一頁文件都能準確無誤、按順序地送達目的地，若有文件丟失或損壞，它會及時要求重新發送。

而 IP（網際協議）則承擔著數據的路由和尋址工作，實現數據包在網絡中的傳輸，它如同快遞員手中的地址簿，根據目標地址將數據包準確地投遞到下一個節點。TCP 協議適用于對數據準確性和完整性要求極高的場景，比如文件下載、網頁瀏覽等，因為在這些場景中，數據的錯誤或丟失可能會導致嚴重的后果，如文件損壞無法打開、網頁顯示錯誤等。

以 TCP 協議的流式套接字為例，連接建立需要通過三次握手來完成。三次握手的過程如下：

第一次握手：客戶端向服務器發送一個 SYN（同步）報文段，該報文段中包含客戶端的初始序列號（Sequence Number，簡稱 Seq），假設為 x 。此時，客戶端進入 SYN_SENT 狀態，等待服務器的響應。這個過程就好比客戶端給服務器打電話說：“我想和你建立連接，這是我的初始序號 x”。
第二次握手：服務器接收到客戶端的 SYN 報文段后，會回復一個 SYN-ACK（同步確認）報文段。該報文段中包含服務器的初始序列號，假設為 y，同時 ACK（確認）字段的值為 x + 1，表示服務器已經收到客戶端的 SYN 報文段，并且確認號為客戶端的序列號加 1。此時，服務器進入 SYN_RCVD 狀態。這就像是服務器接起電話回應客戶端：“我收到你的連接請求了，這是我的初始序號 y，我確認收到了你的序號 x”。
第三次握手：客戶端接收到服務器的 SYN-ACK 報文段后，會發送一個 ACK 報文段給服務器。該報文段的 ACK 字段的值為 y + 1，表示客戶端已經收到服務器的 SYN-ACK 報文段，并且確認號為服務器的序列號加 1。此時，客戶端進入 ESTABLISHED 狀態，服務器接收到 ACK 報文段后也進入 ESTABLISHED 狀態，連接建立成功。這相當于客戶端再次回應服務器：“我收到你的回復了，連接建立成功，我們可以開始通信了”。

三次握手的作用在于確保雙方的通信能力正常，并且能夠同步初始序列號，為后續的數據傳輸建立可靠的基礎。通過三次握手，客戶端和服務器都能確認對方可以正常接收和發送數據，避免了舊連接請求的干擾，保證了連接的唯一性和正確性

UDP/IP 協議中的 UDP（用戶數據報協議）則是另一種風格，它是一種無連接的協議，不保證數據傳輸的可靠性和順序性。UDP 協議在傳輸數據時，就像一位追求速度的快遞員，直接將數據包發送出去，不關心是否能夠準確送達以及到達的順序。雖然 UDP 不提供可靠的傳輸保障，但它具有傳輸速度快、開銷小的優點，適用于對實時性要求較高、數據丟失可以容忍的場景，如音視頻傳輸、在線游戲等。在視頻會議中，偶爾丟失幾個數據包可能只會導致短暫的畫面卡頓，但不會影響整個會議的進行，而 UDP 協議的快速傳輸特性能夠保證視頻和音頻的流暢播放，讓參會者獲得較好的體驗。

在數據傳輸階段，發送端和接收端的數據流動過程如下：

發送端：應用程序調用write或send函數將數據發送到 Socket 。這些函數會將應用程序緩沖區中的數據拷貝到 Socket 的發送緩沖區中。然后，內核會根據 Socket 的類型和協議，對數據進行封裝。對于 TCP 套接字，數據會被分割成 TCP 段，并添加 TCP 頭部，包括源端口、目標端口、序列號、確認號等信息；對于 UDP 套接字，數據會被封裝成 UDP 數據報，并添加 UDP 頭部，包含源端口和目標端口。接著，數據會被傳遞到網絡層，添加 IP 頭部，包含源 IP 地址和目標 IP 地址，形成 IP 數據包。最后，IP 數據包通過網絡接口層發送到物理網絡上。
接收端：數據從物理網絡進入接收端的網絡接口層。網絡接口層接收到 IP 數據包后，會進行解包，將 IP 頭部去除，然后將數據傳遞到網絡層。網絡層根據 IP 頭部中的目標 IP 地址，判斷該數據包是否是發給本機的。如果是，則去除 IP 頭部，將數據傳遞到傳輸層。傳輸層根據協議類型（TCP 或 UDP），對數據進行相應的處理。對于 TCP 數據，會檢查序列號和確認號，進行流量控制和錯誤重傳等操作；對于 UDP 數據，直接去除 UDP 頭部，將數據傳遞到 Socket 的接收緩沖區。最后，應用程序調用read或recv函數從 Socket 的接收緩沖區中讀取數據到應用程序緩沖區中，完成數據的接收。

當數據在網絡中傳輸時，它會經歷一系列復雜的過程。應用層的數據首先會被封裝成數據包，然后依次經過傳輸層、網絡層和數據鏈路層，每一層都會添加相應的頭部信息，以實現不同的功能。在傳輸過程中，可能會出現粘包和分包的問題。粘包現象通常發生在 TCP 協議中，由于 TCP 是面向流的協議，數據在發送時可能會被合并成一個大的數據包發送，或者接收方沒有及時讀取數據，導致多個數據包被一起讀取，就像多個快遞包裹被捆在一起送到了收件人手中，收件人難以區分每個包裹的內容。分包則是指一個大的數據包由于網絡傳輸的限制（如 MTU，最大傳輸單元），被分割成多個小的數據包進行傳輸，到了接收方再進行重組，這就好比一個大的快遞被拆分成多個小包裹分別發送，收件人需要將這些小包裹重新組裝成完整的物品。

為了解決粘包和分包問題，常見的方法有定包長、包尾加分隔符號、包頭加上包體長度等。以包頭加上包體長度的方法為例，在發送數據時，先在數據包的頭部添加一個固定長度的字段，用于表示包體的長度，接收方在接收到數據后，首先讀取包頭中的長度字段，然后根據這個長度來準確地讀取包體的數據，這樣就能確保每個數據包都能被正確地解析，避免了粘包和分包帶來的混亂。

在高并發服務器開發中，深入理解網絡協議和數據傳輸過程，以及掌握解決粘包、分包等問題的方法，是構建高性能、穩定網絡應用的關鍵所在。

Part3.C++多線程網絡編程實踐

3.1多線程服務器架構設計

在構建高并發服務器時，精心設計多線程服務器架構至關重要，它就如同建造摩天大樓的藍圖，直接決定了服務器的性能、可擴展性和穩定性。

一種常見且高效的多線程服務器架構模式是主從線程模型。在這個模型中，主線程猶如一位經驗豐富的指揮官，承擔著監聽端口和接受新連接的重要職責。一旦捕捉到新的連接請求，它便迅速將這個連接分配給工作線程池中的某個工作線程。工作線程則像是一群訓練有素的士兵，專注于與客戶端進行數據的收發和處理工作。這種分工明確的模式，使得主線程能夠心無旁騖地專注于新連接的接納，而工作線程可以全身心地投入到數據處理中，極大地提高了服務器的并發處理能力。

線程池作為多線程服務器架構中的關鍵組件，發揮著不可或缺的作用。線程池就像是一個訓練有素的團隊，預先創建一定數量的線程，這些線程在空閑時處于待命狀態，一旦有任務下達，它們便能迅速響應，投入工作。通過線程池，我們可以有效避免頻繁創建和銷毀線程所帶來的巨大開銷。線程的創建和銷毀就好比是反復招募和解雇員工，不僅耗時費力，還會造成資源的浪費。而線程池則像是一個穩定的團隊，員工們可以持續工作，大大提高了效率。線程池還能夠對線程數量進行精細控制，防止因線程過多而導致系統資源被過度消耗，從而確保服務器在高并發環境下依然能夠穩定運行。

為了更直觀地理解多線程服務器架構，我們來看一個簡化的示例代碼，展示如何使用 C++ 和線程池來構建一個簡單的多線程服務器：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

// 線程池類
class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] { return this->stop ||!this->tasks.empty(); });
                        if (this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
};

// 處理客戶端連接的函數
void handleClient(int clientSocket) {
    char buffer[1024] = {0};
    int valread = read(clientSocket, buffer, 1024);
    std::cout << "Received: " << buffer << std::endl;

    const char *response = "Hello from server";
    send(clientSocket, response, strlen(response), 0);
    std::cout << "Response sent" << std::endl;

    close(clientSocket);
}

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    if (bind(serverSocket, (struct sockaddr *) &address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(serverSocket, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    ThreadPool pool(4); // 創建包含4個線程的線程池

    while (true) {
        struct sockaddr_in clientAddress;
        socklen_t clientAddressLen = sizeof(clientAddress);
        int clientSocket = accept(serverSocket, (struct sockaddr *) &clientAddress, &clientAddressLen);
        if (clientSocket < 0) {
            perror("accept");
            continue;
        }

        // 將處理客戶端連接的任務加入線程池
        pool.enqueue([clientSocket] {
            handleClient(clientSocket);
        });
    }

    close(serverSocket);
    return 0;
}

在這段代碼中，ThreadPool類實現了一個簡單的線程池，通過構造函數創建指定數量的線程，并在析構函數中正確地停止和回收這些線程。enqueue方法用于將任務添加到任務隊列中，并通知一個等待的線程來執行任務。handleClient函數負責處理客戶端的連接，接收客戶端發送的數據并返回響應。在main函數中，創建了一個服務器套接字，監聽指定端口，并將接收到的客戶端連接任務提交給線程池處理。

通過這樣的架構設計和線程池的運用，我們能夠構建出一個高效、穩定的多線程服務器，為高并發場景下的網絡通信提供堅實的基礎。

3.2線程同步與互斥

在多線程編程的復雜世界里，線程同步與互斥是確保程序正確運行的關鍵環節，就如同交通規則對于城市交通的重要性一樣。當多個線程同時訪問和修改共享資源時，如果沒有有效的同步機制，就可能引發一系列嚴重的問題，如數據競爭和數據不一致。數據競爭就像是多個司機在沒有交通規則的路口爭搶通行，導致交通堵塞和混亂；而數據不一致則好比是不同的人對同一份文件進行修改，卻沒有協調好，最終使得文件內容混亂不堪。

為了有效解決這些問題，C++ 提供了一系列強大的同步工具，其中互斥鎖（std::mutex）和條件變量（std::condition_variable）是最為常用的。

互斥鎖（std::mutex）是一種簡單而有效的同步機制，它就像是一扇門，一次只允許一個線程進入臨界區，訪問共享資源。當一個線程獲取到互斥鎖時，就相當于拿到了這扇門的鑰匙，其他線程必須等待，直到該線程釋放互斥鎖，將鑰匙歸還，其他線程才有機會進入。例如，在一個多線程的銀行賬戶管理系統中，多個線程可能同時嘗試對賬戶余額進行修改，如果沒有互斥鎖的保護，就可能出現數據不一致的情況，導致賬戶余額錯誤。使用互斥鎖可以確保在任何時刻，只有一個線程能夠對賬戶余額進行操作，從而保證數據的一致性。

下面是一個使用互斥鎖的簡單示例代碼：

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx; // 創建一個互斥鎖
int sharedResource = 0; // 共享資源

void increment() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock(); // 加鎖，進入臨界區
        ++sharedResource; // 訪問和修改共享資源
        mtx.unlock(); // 解鎖，離開臨界區
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final value of sharedResource: " << sharedResource << std::endl;
    return 0;
}

在這個示例中，std::mutex對象mtx用于保護sharedResource的訪問。在increment函數中，通過調用mtx.lock()來獲取鎖，進入臨界區，對sharedResource進行操作，操作完成后，調用mtx.unlock()釋放鎖，離開臨界區。這樣，就保證了在同一時間只有一個線程能夠修改sharedResource，避免了數據競爭。

條件變量（std::condition_variable）則是一種更高級的同步工具，它允許線程在特定條件滿足時被喚醒，從而實現線程之間的協作。條件變量通常與互斥鎖配合使用，就像是一個信號燈，當條件不滿足時，線程可以在條件變量上等待，釋放互斥鎖，進入睡眠狀態；當條件滿足時，其他線程可以通知條件變量，喚醒等待的線程，使其重新獲取互斥鎖，繼續執行。例如，在一個生產者 - 消費者模型中，生產者線程生產數據并放入緩沖區，消費者線程從緩沖區中取出數據進行處理。當緩沖區為空時，消費者線程需要等待生產者線程生產數據；當緩沖區滿時，生產者線程需要等待消費者線程取出數據。通過條件變量，我們可以實現生產者和消費者線程之間的高效協作。

下面是一個使用條件變量的示例代碼：

#include <iostream>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>

std::mutex mtx;
std::condition_variable cv;
std::queue<int> dataQueue;

// 生產者線程函數
void producer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        dataQueue.push(i);
        std::cout << "Produced: " << i << std::endl;
        lock.unlock();
        cv.notify_one(); // 通知一個等待的消費者線程
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 消費者線程函數
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return!dataQueue.empty(); }); // 等待隊列中有數據
        int data = dataQueue.front();
        dataQueue.pop();
        std::cout << "Consumed: " << data << std::endl;
        lock.unlock();
        if (data == 9) break; // 當消費完最后一個數據時退出
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();

    return 0;
}

在這個示例中，std::condition_variable對象cv用于協調生產者和消費者線程。生產者線程在生產數據后，通過cv.notify_one()通知等待的消費者線程；消費者線程在cv.wait(lock, [] { return!dataQueue.empty(); });處等待，直到隊列中有數據時被喚醒，然后從隊列中取出數據進行處理。

通過合理使用互斥鎖和條件變量，我們能夠有效地實現線程同步與互斥，確保多線程程序的正確性和穩定性。

3.3并發控制策略

在多線程編程的廣袤領域中，并發控制策略猶如精密儀器中的調節裝置，對于確保程序在高并發環境下的高效、穩定運行起著至關重要的作用。除了前面介紹的互斥鎖和條件變量等基本同步機制外，無鎖數據結構和讀寫鎖等高級并發控制策略，為我們應對復雜的多線程場景提供了更為強大的工具。

無鎖數據結構，作為一種獨特的并發控制方案，通過采用先進的算法和技術，巧妙地避免了傳統鎖機制帶來的性能瓶頸和死鎖風險。它就像是一個高效的自動化工廠，各個生產線（線程）可以在無需等待鎖的情況下，同時對共享資源進行操作，極大地提高了系統的并發性能。無鎖數據結構通常依賴于原子操作，如比較并交換（CAS，Compare-And-Swap）操作，來實現數據的安全訪問和修改。CAS 操作就像是一位公正的裁判，它會在修改數據之前，先仔細檢查數據的當前值是否與預期值一致，如果一致，才會進行修改，否則就放棄操作。這種方式使得多個線程能夠在不使用鎖的情況下，安全地并發訪問共享數據。

以無鎖鏈表為例，它在實現上摒棄了傳統鏈表中對鎖的依賴，通過精心設計的節點結構和原子操作，實現了高效的并發插入和刪除操作。在無鎖鏈表中，每個節點都包含一個指向下一個節點的指針，并且這些指針的更新操作都是通過原子操作來完成的。當一個線程想要插入一個新節點時，它會首先找到合適的位置，然后使用 CAS 操作將新節點插入到鏈表中。如果在插入過程中，其他線程同時對鏈表進行了修改，導致當前線程的預期值與實際值不一致，那么當前線程會重新嘗試插入操作，直到成功為止。

下面是一個簡化的無鎖鏈表實現示例（僅展示關鍵部分）：

#include <atomic>

template <typename T>
struct Node {
    T data;
    std::atomic<Node<T>*> next;
    Node(const T& value) : data(value), next(nullptr) {}
};

template <typename T>
class LockFreeList {
public:
    LockFreeList() : head(nullptr) {}

    bool insert(const T& value) {
        Node<T> *newNode = new Node<T>(value);
        Node<T> *prev = nullptr;
        Node<T> *curr = head.load();

        while (curr != nullptr && curr->data < value) {
            prev = curr;
            curr = curr->next.load();
        }

        if (curr != nullptr && curr->data == value) {
            delete newNode;
            return false; // 數據已存在，插入失敗
        }

        newNode->next.store(curr);
        if (prev == nullptr) {
            while (!head.compare_exchange_weak(curr, newNode)) {
                if (curr != nullptr && curr->data < value) {
                    prev = curr;
                    curr = curr->next.load();
                } else {
                    break;
                }
            }
        } else {
            while (!prev->next.compare_exchange_weak(curr, newNode)) {
                if (curr != nullptr && curr->data < value) {
                    prev = curr;
                    curr = curr->next.load();
                } else {
                    break;
                }
            }
        }

        return true;
    }

private:
    std::atomic<Node<T>*> head;
};

在這個示例中，LockFreeList類實現了一個簡單的無鎖鏈表。insert方法使用 CAS 操作來插入新節點，確保在多線程環境下的正確性和高效性。

讀寫鎖（std::shared_mutex）則是另一種重要的并發控制策略，它專門針對讀多寫少的場景進行了優化。讀寫鎖就像是一個智能的門禁系統，當多個線程同時進行讀操作時，它允許這些線程同時進入，共享資源；但當有線程進行寫操作時，它會立即禁止其他線程的讀寫操作，以保證數據的一致性。這種機制大大提高了讀操作的并發性能，減少了線程之間的競爭。

在 C++ 中，std::shared_mutex提供了讀寫鎖的功能。線程可以通過調用lock_shared方法來獲取共享鎖（讀鎖），允許多個線程同時持有共享鎖進行讀操作；通過調用lock方法來獲取獨占鎖（寫鎖），此時其他線程無法獲取任何鎖，直到獨占鎖被釋放。

以下是一個使用讀寫鎖的示例代碼：

#include <iostream>
#include <shared_mutex>
#include <thread>

std::shared_mutex rwMutex;
int sharedData = 0;

// 讀操作
void readData() {
    rwMutex.lock_shared();
    std::cout << "Read data: " << sharedData << std::endl;
    rwMutex.unlock_shared();
}

// 寫操作
void writeData(int value) {
    rwMutex.lock();
    sharedData = value;
    std::cout << "Write data: " << value << std::endl;
    rwMutex.unlock();
}

int main() {
    std::thread t1(readData);
    std::thread t2(readData);
    std::thread t3(writeData, 42);
    std::thread t4(readData);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

在這個示例中，std::shared_mutex對象rwMutex用于保護sharedData的讀寫操作。讀操作通過lock_shared和unlock_shared來獲取和釋放共享鎖，允許多個讀線程同時訪問；寫操作通過lock和unlock來獲取和釋放獨占鎖，確保在寫操作時沒有其他線程可以訪問sharedData 。

通過靈活運用無鎖數據結構和讀寫鎖等并發控制策略，我們能夠根據不同的應用場景和需求，選擇最合適的方案，提升多線程程序的性能和并發處理能力。

3.4 I/O 多路復用技術

在編程世界里，I/O 操作（如文件讀寫、網絡通信等）是非常常見的任務。傳統的 I/O 模型中，一個線程通常只能處理一個 I/O 操作，如果要處理多個 I/O 操作，就需要創建多個線程或者進程，這會帶來資源浪費和復雜度增加的問題。

IO 多路復用（I/O Multiplexing）技術的出現，很好地解決了這個問題。它允許一個進程同時監聽多個文件描述符（File Descriptor，簡稱 fd，在 Linux 系統中，一切皆文件，文件描述符是內核為了高效管理已被打開的文件所創建的索引）的 I/O 事件，當某個文件描述符就緒（有數據可讀、可寫或有異常發生）時，進程能夠及時得到通知并進行相應的處理。這就好比一個餐廳服務員，他可以同時照顧多桌客人，當某一桌客人有需求（比如需要加水、上菜等）時，服務員能夠及時響應，而不是一個服務員只服務一桌客人，造成資源浪費。

在 Linux 系統中，常見的 IO 多路復用方式有 select、poll 和 epoll，它們各自有著不同的特點和適用場景。

①select：select 是最早出現的 IO 多路復用方式，它通過一個select()系統調用來監視多個文件描述符的數組。select()函數的原型如下：

#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

參數說明

nfds：需要監聽的文件描述符的最大值加 1。
readfds：需要監聽讀事件的文件描述符集合。
writefds：需要監聽寫事件的文件描述符集合。
exceptfds：需要監聽異常事件的文件描述符集合。
timeout：設置select函數的超時時間，如果為NULL，則表示一直阻塞等待。

返回值說明

成功時返回就緒文件描述符個數。
超時時返回 0。
出錯時返回負值。

使用select時，需要先初始化文件描述符集合，將需要監聽的文件描述符添加到對應的集合中，然后調用select函數。當select返回后，通過檢查返回值和文件描述符集合，判斷哪些文件描述符就緒，進而進行相應的讀寫操作。例如：

#include <iostream>
#include <sys/select.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>

#define PORT 8080
#define MAX_CLIENTS 10

int main() {
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("socket creation failed");
        return 1;
    }

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        close(server_socket);
        return 1;
    }

    if (listen(server_socket, 3) == -1) {
        perror("listen failed");
        close(server_socket);
        return 1;
    }

    fd_set read_fds;
    FD_ZERO(&read_fds);
    FD_SET(server_socket, &read_fds);
    int max_fd = server_socket;

    while (true) {
        fd_set temp_fds = read_fds;
        int activity = select(max_fd + 1, &temp_fds, NULL, NULL, NULL);
        if (activity == -1) {
            perror("select error");
            break;
        } else if (activity > 0) {
            if (FD_ISSET(server_socket, &temp_fds)) {
                int client_socket = accept(server_socket, NULL, NULL);
                if (client_socket != -1) {
                    FD_SET(client_socket, &read_fds);
                    if (client_socket > max_fd) {
                        max_fd = client_socket;
                    }
                }
            }

            for (int i = 0; i <= max_fd; ++i) {
                if (FD_ISSET(i, &temp_fds) && i != server_socket) {
                    char buffer[1024] = {0};
                    int valread = read(i, buffer, sizeof(buffer));
                    if (valread == -1) {
                        perror("read failed");
                        close(i);
                        FD_CLR(i, &read_fds);
                    } else if (valread == 0) {
                        close(i);
                        FD_CLR(i, &read_fds);
                    } else {
                        std::cout << "Received: " << buffer << std::endl;
                    }
                }
            }
        }
    }

    close(server_socket);
    return 0;
}

這段代碼創建了一個簡單的 TCP 服務器，使用select監聽新的客戶端連接和客戶端發送的數據。

select 的優點是幾乎在所有平臺上都支持，具有良好的跨平臺性；缺點是單個進程能夠監視的文件描述符數量有限，在 Linux 上一般為 1024，并且每次調用select都需要將文件描述符集合從用戶態拷貝到內核態，隨著文件描述符數量的增大，其復制和遍歷的開銷也會線性增長。

②poll：poll 出現的時間比 select 稍晚，它和 select 在本質上沒有太大差別，也是通過輪詢的方式來檢查文件描述符是否就緒。poll函數的原型如下：

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

參數說明—fds：一個指向struct pollfd結構體數組的指針，struct pollfd結構體定義如下：

struct pollfd {
    int fd;         // 文件描述符
    short events;   // 等待的事件
    short revents;  // 實際發生的事件
};

nfds：指定fds數組中結構體的個數。
timeout：設置超時時間，單位是毫秒。

返回值說明：

成功時返回就緒文件描述符個數。
超時時返回 0。
出錯時返回負值。

與 select 相比，poll 沒有最大文件描述符數量的限制，并且它將輸入輸出參數進行了分離，不需要每次都重新設定。但是，poll 同樣存在包含大量文件描述符的數組被整體復制于用戶態和內核的地址空間之間的問題，其開銷隨著文件描述符數量的增加而線性增大。

③epoll：epoll 是在 Linux 2.6 內核中引入的，它被公認為是 Linux 下性能最好的多路 I/O 就緒通知方法。

epoll 有三個主要函數：

⑴epoll_create：用于創建一個 epoll 實例，返回一個 epoll 專用的文件描述符。

#include <sys/epoll.h>

int epoll_create(int size);

這里的size參數在 Linux 2.6.8 版本之后被忽略，但仍需傳入一個大于 0 的值。

⑵epoll_ctl：用于控制某個 epoll 實例監聽的文件描述符，比如添加、刪除或修改監聽事件。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

參數說明：

epfd：epoll 實例的文件描述符。
op：操作類型，有EPOLL_CTL_ADD（添加）、EPOLL_CTL_MOD（修改）、EPOLL_CTL_DEL（刪除）。
fd：要操作的文件描述符。

event：指向struct epoll_event結構體的指針，用于設置監聽的事件和關聯的數據，struct epoll_event結構體定義如下：

struct epoll_event {
    uint32_t events;      // Epoll事件
    epoll_data_t data;    // 用戶數據
};

其中，events可以是EPOLLIN（可讀事件）、EPOLLOUT（可寫事件）等事件的組合；data可以是一個void*指針，用于關聯用戶自定義的數據。

⑶epoll_wait：用于等待 epoll 實例上的事件發生，返回就緒的事件列表。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

參數說明

epfd：epoll 實例的文件描述符。
events：用于存儲就緒事件的數組。
maxevents：指定events數組的大小。
timeout：設置超時時間，單位是毫秒，若為 - 1 則表示一直阻塞。

返回值說明

成功時返回就緒事件的個數。
超時時返回 0。
出錯時返回負值。

epoll 使用一個文件描述符管理多個描述符，將用戶關心的文件描述符的事件存放到內核的一個事件表中，這樣在用戶空間和內核空間的拷貝只需一次。而且，epoll 采用基于事件的就緒通知方式，當某個文件描述符就緒時，內核會采用類似 callback 的回調機制，迅速激活這個文件描述符，當進程調用epoll_wait時便得到通知，大大提高了效率。

綜上所述，select、poll 和 epoll 各有優劣，在實際應用中，我們需要根據具體的需求和場景來選擇合適的 IO 多路復用方式。如果需要跨平臺支持，且文件描述符數量較少，select 是一個不錯的選擇；如果需要處理大量的文件描述符，且對性能要求較高，epoll 則是更好的選擇；而 poll 則處于兩者之間，在一些特定場景下也有其用武之地。

Part4.實戰案例：高并發聊天服務器的實現

4.1功能需求分析

在當今數字化社交高度發達的時代，即時通訊軟件如微信、QQ 等已成為人們日常生活中不可或缺的溝通工具。為了打造一款能夠滿足現代用戶需求的高并發聊天服務器，我們需要全面而細致地剖析其功能需求。

用戶注冊登錄功能是聊天服務器的基礎門檻，它就像是進入社交大廈的鑰匙，只有通過注冊獲得專屬賬號，并成功登錄，用戶才能開啟與他人交流的大門。在實現這一功能時，需要確保用戶賬號的唯一性，如同每個人的身份證號碼獨一無二一樣，避免賬號沖突。同時，要采用安全可靠的密碼加密存儲方式，比如使用強大的哈希算法，如 SHA - 256，將用戶密碼進行加密處理后存儲在數據庫中，防止密碼明文泄露，保障用戶賬號的安全。

群組聊天功能是社交互動的核心舞臺，它讓用戶能夠像參加熱鬧的派對一樣，與志同道合的人在同一個群組中暢所欲言。服務器需要高效地管理群組信息，包括群組的創建、成員的加入和退出等操作。當有新消息在群組中發布時，服務器要能夠迅速將消息準確無誤地廣播給群內的每一個成員，確保信息的實時傳遞。

私聊功能則為用戶提供了一個私密的交流空間，就像是在熱鬧的派對中找一個安靜的角落，與特定的人進行一對一的深入交談。服務器需要精準地處理私聊消息的路由，確保消息能夠準確無誤地送達目標用戶，避免消息誤發或丟失。

消息推送功能是保持用戶與服務器實時連接的紐帶，它能讓用戶在第一時間收到新消息的通知，就像快遞員及時將包裹送到收件人手中一樣。服務器需要支持實時推送，采用如 WebSocket 等高效的通信協議，實現消息的即時傳輸，讓用戶感受到流暢的聊天體驗。

4.2代碼實現與解析

接下來，讓我們深入探討高并發聊天服務器的核心代碼實現，通過實際代碼來感受多線程網絡編程在構建聊天服務器中的強大魅力。

服務器端代碼實現：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <unordered_map>
#include <string>

// 線程池類
class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] { return this->stop ||!this->tasks.empty(); });
                        if (this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

    template<class F, class... Args>
    void enqueue(F&& f, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
};

// 用戶信息結構體
struct User {
    std::string username;
    int socketFd;
};

std::unordered_map<int, User> users; // 存儲在線用戶
std::mutex usersMutex; // 保護用戶信息的互斥鎖

// 處理客戶端連接的函數
void handleClient(int clientSocket) {
    char buffer[1024] = {0};
    int valread = read(clientSocket, buffer, 1024);
    if (valread < 0) {
        perror("read failed");
        close(clientSocket);
        return;
    }

    std::string message(buffer, valread);
    // 解析消息，假設消息格式為 "command|data"，例如 "login|username"
    size_t pos = message.find('|');
    if (pos == std::string::npos) {
        std::cerr << "Invalid message format" << std::endl;
        close(clientSocket);
        return;
    }

    std::string command = message.substr(0, pos);
    std::string data = message.substr(pos + 1);

    if (command == "login") {
        {
            std::lock_guard<std::mutex> lock(usersMutex);
            User user = {data, clientSocket};
            users[clientSocket] = user;
            std::cout << "User " << data << " logged in" << std::endl;
        }
        const char* response = "Login successful";
        send(clientSocket, response, strlen(response), 0);
    } else if (command == "send") {
        // 解析發送消息的目標用戶和內容，假設格式為 "target_user|message_content"
        pos = data.find('|');
        if (pos == std::string::npos) {
            std::cerr << "Invalid send message format" << std::endl;
            close(clientSocket);
            return;
        }
        std::string targetUser = data.substr(0, pos);
        std::string messageContent = data.substr(pos + 1);

        {
            std::lock_guard<std::mutex> lock(usersMutex);
            for (auto& user : users) {
                if (user.second.username == targetUser) {
                    std::string fullMessage = users[clientSocket].username + " says: " + messageContent;
                    send(user.second.socketFd, fullMessage.c_str(), fullMessage.size(), 0);
                    break;
                }
            }
        }
    } else {
        std::cerr << "Unknown command: " << command << std::endl;
        close(clientSocket);
        return;
    }

    while (true) {
        valread = read(clientSocket, buffer, 1024);
        if (valread < 0) {
            perror("read failed");
            break;
        } else if (valread == 0) {
            std::cout << "Client disconnected" << std::endl;
            break;
        }

        message.assign(buffer, valread);
        // 處理其他消息，如群組消息等
    }

    {
        std::lock_guard<std::mutex> lock(usersMutex);
        users.erase(clientSocket);
    }
    close(clientSocket);
}

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    if (bind(serverSocket, (struct sockaddr *) &address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(serverSocket, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    ThreadPool pool(4); // 創建包含4個線程的線程池

    while (true) {
        struct sockaddr_in clientAddress;
        socklen_t clientAddressLen = sizeof(clientAddress);
        int clientSocket = accept(serverSocket, (struct sockaddr *) &clientAddress, &clientAddressLen);
        if (clientSocket < 0) {
            perror("accept");
            continue;
        }

        // 將處理客戶端連接的任務加入線程池
        pool.enqueue([clientSocket] {
            handleClient(clientSocket);
        });
    }

    close(serverSocket);
    return 0;
}

在這段服務器端代碼中，ThreadPool類實現了一個線程池，用于高效地處理多個客戶端連接。handleClient函數負責處理單個客戶端的連接，解析客戶端發送的消息，并根據不同的命令（如登錄、發送消息等）進行相應的處理。users是一個std::unordered_map，用于存儲在線用戶的信息，通過usersMutex互斥鎖來保證對用戶信息的安全訪問。

客戶端代碼實現：

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <thread>

void receiveMessages(int socketFd) {
    char buffer[1024] = {0};
    while (true) {
        int valread = read(socketFd, buffer, 1024);
        if (valread < 0) {
            perror("read failed");
            break;
        } else if (valread == 0) {
            std::cout << "Server disconnected" << std::endl;
            break;
        }

        std::string message(buffer, valread);
        std::cout << "Received: " << message << std::endl;
    }
}

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address/ Address not supported" << std::endl;
        return -1;
    }

    if (connect(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection Failed" << std::endl;
        return -1;
    }

    std::thread receiveThread(receiveMessages, sock);

    char buffer[1024] = {0};
    while (true) {
        std::cout << "Enter message: ";
        std::cin.getline(buffer, 1024);

        if (send(sock, buffer, strlen(buffer), 0) < 0) {
            std::cerr << "Send failed" << std::endl;
            break;
        }

        if (strcmp(buffer, "exit") == 0) {
            break;
        }
    }

    receiveThread.join();
    close(sock);
    return 0;
}

客戶端代碼中，receiveMessages函數在一個單獨的線程中運行，負責接收服務器發送的消息并輸出到控制臺。main函數中，創建套接字并連接到服務器，然后啟動接收線程，同時通過std::cin獲取用戶輸入的消息，并發送給服務器。

4.3性能優化與測試

為了讓高并發聊天服務器在實際應用中能夠穩定高效地運行，我們需要對其進行一系列的性能優化。

優化 I/O 操作也至關重要。可以采用 I/O 多路復用技術，如epoll（在 Linux 系統上），來替代傳統的阻塞 I/O。epoll能夠在一個線程中同時監控多個文件描述符的狀態，當有事件發生時，及時通知程序進行處理，大大提高了 I/O 的效率。

接下來，我們通過性能測試工具來展示優化前后的效果對比。使用Webbench等工具對聊天服務器進行性能測試，模擬大量并發用戶連接到服務器，發送和接收消息。

在優化前，當并發用戶數達到 100 時，服務器的響應時間明顯增加，部分消息的處理出現延遲，甚至出現丟包現象。這是因為傳統的阻塞 I/O 和頻繁的鎖競爭導致服務器的處理能力達到了瓶頸。

經過性能優化后，同樣在100個并發用戶的情況下，服務器的響應時間大幅縮短，消息能夠及時準確地處理和傳輸，丟包現象也基本消失；這充分展示了減少鎖使用和優化I/O操作對提升服務器性能的顯著效果。

通過不斷地優化和測試，我們能夠打造出一個高性能、穩定可靠的高并發聊天服務器，為用戶提供更加流暢、高效的聊天體驗。

責任編輯：武曉燕來源：深度Linux

C++多線程網絡