MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++网络编程中同步与异步IO的区分

2023-07-304.6k 阅读

一、C++网络编程基础

在深入探讨同步与异步 I/O 之前，先来回顾一下 C++网络编程的基本概念。网络编程涉及通过网络协议进行数据的发送和接收，这在现代应用开发，尤其是服务器端开发、分布式系统和实时应用中至关重要。

（一）套接字（Socket）

套接字是网络编程的核心概念，它是应用程序与网络之间的接口。在 C++ 中，我们通常使用 Berkeley Sockets API 来进行套接字编程。以下是一个简单的创建套接字的代码示例：

#include <iostream>
#include <winsock2.h>

#pragma comment(lib, "ws2_32.lib")

int main() {
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        std::cout << "WSAStartup failed: " << iResult << std::endl;
        return 1;
    }

    SOCKET listenSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (listenSocket == INVALID_SOCKET) {
        std::cout << "Socket creation failed: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    sockaddr_in service;
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = INADDR_ANY;
    service.sin_port = htons(27015);

    if (bind(listenSocket, (SOCKADDR*)&service, sizeof(service)) == SOCKET_ERROR) {
        std::cout << "Bind failed: " << WSAGetLastError() << std::endl;
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    if (listen(listenSocket, 5) == SOCKET_ERROR) {
        std::cout << "Listen failed: " << WSAGetLastError() << std::endl;
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Waiting for a connection..." << std::endl;
    SOCKET clientSocket = accept(listenSocket, NULL, NULL);
    if (clientSocket == INVALID_SOCKET) {
        std::cout << "Accept failed: " << WSAGetLastError() << std::endl;
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    char recvbuf[512];
    int iSendResult;
    int recvbuflen = 512;

    // 接收数据
    int iResult = recv(clientSocket, recvbuf, recvbuflen, 0);
    if (iResult > 0) {
        std::cout << "Bytes received: " << iResult << std::endl;
        recvbuf[iResult] = '\0';
        std::cout << "Received: " << recvbuf << std::endl;

        // 发送响应
        iSendResult = send(clientSocket, "Hello from server", strlen("Hello from server"), 0);
        if (iSendResult == SOCKET_ERROR) {
            std::cout << "Send failed: " << WSAGetLastError() << std::endl;
            closesocket(clientSocket);
            closesocket(listenSocket);
            WSACleanup();
            return 1;
        }
        std::cout << "Bytes sent: " << iSendResult << std::endl;
    } else if (iResult == 0) {
        std::cout << "Connection closing..." << std::endl;
    } else {
        std::cout << "Recv failed: " << WSAGetLastError() << std::endl;
        closesocket(clientSocket);
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    // 关闭连接
    iResult = shutdown(clientSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
        std::cout << "Shutdown failed: " << WSAGetLastError() << std::endl;
        closesocket(clientSocket);
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    closesocket(clientSocket);
    closesocket(listenSocket);
    WSACleanup();
    return 0;
}

上述代码展示了一个简单的服务器端程序，使用套接字创建监听套接字，绑定到指定端口，监听连接，接受客户端连接，接收客户端数据并发送响应，最后关闭连接。

（二）网络协议

  1. TCP（传输控制协议） TCP 是一种面向连接的、可靠的传输协议。它通过三次握手建立连接，保证数据的有序传输和完整性。在上述代码中，我们使用 SOCK_STREAM 类型的套接字，这就是基于 TCP 协议的。TCP 适用于对数据准确性和顺序要求较高的应用，如文件传输、HTTP 协议等。
  2. UDP（用户数据报协议） UDP 是一种无连接的、不可靠的传输协议。它不保证数据的有序到达和完整性，但具有较低的开销和延迟。在 C++ 中，可以使用 SOCK_DGRAM 类型的套接字来使用 UDP 协议。UDP 适用于对实时性要求较高，对数据准确性要求相对较低的应用，如实时视频流、音频流等。

二、同步 I/O

（一）同步 I/O 的概念

同步 I/O 意味着在进行 I/O 操作时，程序会阻塞当前线程，直到 I/O 操作完成。例如，当使用 recv 函数接收数据时，线程会一直等待，直到有数据可读或者发生错误。这种方式简单直接，编程模型相对容易理解和实现。

（二）同步 I/O 的优缺点

  1. 优点
    • 简单直观：编程逻辑清晰，对于初学者容易上手。在上述服务器代码中，使用 recv 和 send 函数进行数据的接收和发送，就是典型的同步 I/O 操作，代码逻辑直接明了。
    • 数据准确性高：由于操作是顺序执行的，不会出现数据竞争等复杂问题，保证了数据的准确性和一致性。
  2. 缺点
    • 性能瓶颈：当 I/O 操作耗时较长时，会阻塞整个线程，导致程序在等待 I/O 完成的过程中无法执行其他任务。例如，如果服务器在接收大量数据时，这段时间内无法处理新的连接请求。
    • 资源浪费：对于高并发场景，每个连接都需要一个线程来处理 I/O，会消耗大量的系统资源，如线程栈空间等。

（三）同步 I/O 代码示例

下面是一个简单的同步 I/O 客户端代码示例，连接到上述服务器并进行数据的发送和接收：

#include <iostream>
#include <winsock2.h>

#pragma comment(lib, "ws2_32.lib")

int main() {
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        std::cout << "WSAStartup failed: " << iResult << std::endl;
        return 1;
    }

    SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (clientSocket == INVALID_SOCKET) {
        std::cout << "Socket creation failed: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    serverAddr.sin_port = htons(27015);

    if (connect(clientSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        std::cout << "Connect failed: " << WSAGetLastError() << std::endl;
        closesocket(clientSocket);
        WSACleanup();
        return 1;
    }

    char sendbuf[] = "Hello from client";
    int iSendResult = send(clientSocket, sendbuf, strlen(sendbuf), 0);
    if (iSendResult == SOCKET_ERROR) {
        std::cout << "Send failed: " << WSAGetLastError() << std::endl;
        closesocket(clientSocket);
        WSACleanup();
        return 1;
    }
    std::cout << "Bytes sent: " << iSendResult << std::endl;

    char recvbuf[512];
    int recvbuflen = 512;
    int iResultRecv = recv(clientSocket, recvbuf, recvbuflen, 0);
    if (iResultRecv > 0) {
        std::cout << "Bytes received: " << iResultRecv << std::endl;
        recvbuf[iResultRecv] = '\0';
        std::cout << "Received: " << recvbuf << std::endl;
    } else if (iResultRecv == 0) {
        std::cout << "Connection closed" << std::endl;
    } else {
        std::cout << "Recv failed: " << WSAGetLastError() << std::endl;
    }

    closesocket(clientSocket);
    WSACleanup();
    return 0;
}

此代码展示了同步 I/O 在客户端的应用，通过 send 发送数据，然后使用 recv 接收服务器的响应，在接收过程中线程处于阻塞状态。

三、异步 I/O

（一）异步 I/O 的概念

异步 I/O 允许程序在发起 I/O 操作后，继续执行其他任务，而无需等待 I/O 操作完成。当 I/O 操作完成时，系统会通过回调函数、事件通知等方式告知程序。这种方式可以显著提高程序的并发性能，特别是在处理大量 I/O 操作时。

（二）异步 I/O 的优缺点

  1. 优点
    • 高并发性能：不会阻塞线程，使得程序可以同时处理多个 I/O 操作，大大提高了系统的并发处理能力。例如，在一个服务器中，可以同时处理多个客户端的连接请求和数据传输，而不会因为某个 I/O 操作的延迟而影响其他操作。
    • 资源利用率高：不需要为每个 I/O 操作创建单独的线程，减少了线程上下文切换的开销和系统资源的消耗。
  2. 缺点
    • 编程复杂度高：异步编程模型需要处理回调函数、事件驱动等复杂机制，代码逻辑相对复杂，调试难度较大。
    • 错误处理复杂：由于 I/O 操作是异步的，错误可能在操作完成后才被发现，这使得错误处理变得更加复杂。

（三）异步 I/O 代码示例

  1. 使用 Windows Sockets 异步选择模型
#include <iostream>
#include <winsock2.h>
#include <windows.h>

#pragma comment(lib, "ws2_32.lib")

#define WM_SOCKET WM_USER + 1

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    PSTR szCmdLine, int iCmdShow) {
    static TCHAR szAppName[] = TEXT("AsyncSocket");
    HWND hwnd;
    MSG msg;
    WNDCLASS wndclass;

    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc = WndProc;
    wndclass.cbClsExtra = 0;
    wndclass.cbWndExtra = 0;
    wndclass.hInstance = hInstance;
    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName = NULL;
    wndclass.lpszClassName = szAppName;

    if (!RegisterClass(&wndclass)) {
        MessageBox(NULL, TEXT("This program requires Windows NT!"),
            szAppName, MB_ICONERROR);
        return 0;
    }

    hwnd = CreateWindow(szAppName, TEXT("Async Socket Example"),
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInstance, NULL);

    ShowWindow(hwnd, iCmdShow);
    UpdateWindow(hwnd);

    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        MessageBox(hwnd, TEXT("WSAStartup failed"), TEXT("Error"), MB_OK);
        return 0;
    }

    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
        MessageBox(hwnd, TEXT("Socket creation failed"), TEXT("Error"), MB_OK);
        WSACleanup();
        return 0;
    }

    WSAAsyncSelect(sock, hwnd, WM_SOCKET, FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    serverAddr.sin_port = htons(27015);

    if (connect(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        if (WSAGetLastError() != WSAEWOULDBLOCK) {
            MessageBox(hwnd, TEXT("Connect failed"), TEXT("Error"), MB_OK);
            closesocket(sock);
            WSACleanup();
            return 0;
        }
    }

    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    closesocket(sock);
    WSACleanup();
    return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message) {
    case WM_SOCKET:
        switch (WSAGETSELECTEVENT(lParam)) {
        case FD_READ:
            // 处理读事件
            {
                SOCKET sock = (SOCKET)wParam;
                char recvbuf[512];
                int iResult = recv(sock, recvbuf, 512, 0);
                if (iResult > 0) {
                    recvbuf[iResult] = '\0';
                    std::cout << "Received: " << recvbuf << std::endl;
                } else if (iResult == 0) {
                    std::cout << "Connection closed" << std::endl;
                } else {
                    std::cout << "Recv failed: " << WSAGetLastError() << std::endl;
                }
            }
            break;
        case FD_WRITE:
            // 处理写事件
            {
                SOCKET sock = (SOCKET)wParam;
                char sendbuf[] = "Hello from async client";
                int iSendResult = send(sock, sendbuf, strlen(sendbuf), 0);
                if (iSendResult == SOCKET_ERROR) {
                    std::cout << "Send failed: " << WSAGetLastError() << std::endl;
                } else {
                    std::cout << "Bytes sent: " << iSendResult << std::endl;
                }
            }
            break;
        case FD_CONNECT:
            std::cout << "Connected to server" << std::endl;
            break;
        case FD_CLOSE:
            std::cout << "Connection closed by server" << std::endl;
            break;
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hwnd, message, wParam, lParam);
    }
    return 0;
}

上述代码使用 Windows Sockets 的异步选择模型，通过 WSAAsyncSelect 函数将套接字与窗口消息绑定，当有相应的 I/O 事件（如读、写、连接、关闭）发生时，窗口会收到 WM_SOCKET 消息，在 WndProc 函数中进行相应的处理。

  1. 使用 Boost.Asio 库实现异步 I/O
#include <iostream>
#include <boost/asio.hpp>

void handle_read(const boost::system::error_code& ec, size_t length, std::shared_ptr<std::string> buffer) {
    if (!ec) {
        std::cout << "Received: " << *buffer << std::endl;
    } else {
        std::cout << "Read failed: " << ec.message() << std::endl;
    }
}

void handle_write(const boost::system::error_code& ec, size_t length) {
    if (!ec) {
        std::cout << "Bytes sent" << std::endl;
    } else {
        std::cout << "Write failed: " << ec.message() << std::endl;
    }
}

void async_client() {
    try {
        boost::asio::io_context io;
        boost::asio::ip::tcp::socket socket(io);
        boost::asio::ip::tcp::resolver resolver(io);
        boost::asio::connect(socket, resolver.resolve({ "127.0.0.1", "27015" }));

        auto buffer = std::make_shared<std::string>("Hello from async client with Boost.Asio");
        boost::asio::async_write(socket, boost::asio::buffer(*buffer),
            [buffer](const boost::system::error_code& ec, size_t length) {
                handle_write(ec, length);
            });

        std::array<char, 512> recv_buffer;
        boost::asio::async_read(socket, boost::asio::buffer(recv_buffer),
            [buffer](const boost::system::error_code& ec, size_t length) {
                auto new_buffer = std::make_shared<std::string>(recv_buffer.data(), length);
                handle_read(ec, length, new_buffer);
            });

        io.run();
    } catch (std::exception& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
}

int main() {
    async_client();
    return 0;
}

此代码使用 Boost.Asio 库实现异步 I/O。通过 async_write 和 async_read 函数发起异步写和读操作，并通过回调函数 handle_write 和 handle_read 处理操作结果。io.run() 函数用于启动事件循环，处理异步操作的完成通知。

四、同步与异步 I/O 的选择

在实际的 C++网络编程中，选择同步还是异步 I/O 取决于具体的应用场景和需求。

  1. 简单应用和低并发场景：如果应用程序逻辑简单，并发连接数较少，同步 I/O 是一个不错的选择。其简单直观的编程模型可以减少开发和维护成本，同时保证数据的准确性。例如，一些小型的本地网络应用，如简单的文件传输工具。
  2. 高并发和性能敏感场景：对于高并发的服务器应用，如 Web 服务器、游戏服务器等，异步 I/O 是更好的选择。它可以显著提高系统的并发处理能力，减少资源消耗，提升整体性能。但需要注意的是，开发人员需要具备更高的技术水平来处理异步编程带来的复杂性。

在进行选择时，还需要考虑项目的开发周期、团队技术能力等因素。有时候，也可以采用混合的方式，对于一些关键的、对性能要求不高的 I/O 操作使用同步方式，而对于大量的、对并发性能要求高的操作使用异步方式，以达到最佳的开发效率和系统性能。

总之，深入理解同步与异步 I/O 的区别和适用场景，是进行高效 C++网络编程的关键。通过合理选择和运用这两种 I/O 方式，可以开发出性能卓越、稳定可靠的网络应用程序。