如何在Linux中用C++处理并发请求

在Linux中使用C++处理并发请求，可以采用多种方法。以下是一些常见的并发模型和相应的实现方式：

1. 多线程：使用C++11标准库中的<thread>头文件来创建和管理线程。

#include <iostream>
#include <thread>
#include <vector>

void handleRequest(int requestId) {
    // 处理请求的代码
    std::cout << "Handling request " << requestId << std::endl;
}

int main() {
    const int numRequests = 10;
    std::vector<std::thread> threads;

    for (int i = 0; i < numRequests; ++i) {
        threads.emplace_back(handleRequest, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

2. 异步I/O：使用C++11的<future>和<async>来执行异步操作。

#include <iostream>
#include <future>
#include <vector>

int handleRequest(int requestId) {
    // 模拟处理请求
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return requestId * 2;
}

int main() {
    const int numRequests = 10;
    std::vector<std::future<int>> futures;

    for (int i = 0; i < numRequests; ++i) {
        futures.push_back(std::async(std::launch::async, handleRequest, i));
    }

    for (auto& f : futures) {
        std::cout << "Processed request with result: " << f.get() << std::endl;
    }

    return 0;
}

3. 事件驱动：使用libevent或libuv等库来处理事件循环和回调。

// 这里只是一个简单的示例，实际使用时需要根据库的API进行编写
#include <event2/event.h>

void eventCallback(evutil_socket_t fd, short what, void *arg) {
    // 处理事件的代码
}

int main() {
    struct event_base *base = event_base_new();
    struct event *ev = event_new(base, -1, EV_READ|EV_PERSIST, eventCallback, NULL);

    event_add(ev, NULL);
    event_base_dispatch(base);

    event_free(ev);
    event_base_free(base);

    return 0;
}

4. Reactor模式：使用boost::asio库来实现Reactor模式。

#include <iostream>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this<Session> {
public:
    Session(tcp::socket socket) : socket_(std::move(socket)) {}

    void start() {
        read();
    }

private:
    void read() {
        auto self(shared_from_this());
        socket_.async_read_some(boost::asio::buffer(data_, max_length),
            [this, self](boost::system::error_code ec, std::size_t length) {
                if (!ec) {
                    write(length);
                }
            });
    }

    void write(std::size_t length) {
        auto self(shared_from_this());
        boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
            [this, self](boost::system::error_code ec, std::size_t /*length*/) {
                if (!ec) {
                    read();
                }
            });
    }

    tcp::socket socket_;
    enum { max_length = 1024 };
    char data_[max_length];
};

class Server {
public:
    Server(boost::asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {
        accept();
    }

private:
    void accept() {
        acceptor_.async_accept(
            [this](boost::system::error_code ec, tcp::socket socket) {
                if (!ec) {
                    std::make_shared<Session>(std::move(socket))->start();
                }
                accept();
            });
    }

    tcp::acceptor acceptor_;
};

int main(int argc, char* argv[]) {
    try {
        boost::asio::io_context io_context;
        Server server(io_context, 12345);
        io_context.run();
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

5. Proactor模式：在Linux中，Proactor模式通常通过异步I/O系统调用（如aio_read和aio_write）实现，但这在C++标准库中没有直接的抽象，可能需要使用平台特定的API或者第三方库。

选择哪种并发模型取决于具体的应用场景和性能需求。例如，如果请求处理是计算密集型的，多线程可能是更好的选择。如果是I/O密集型的，异步I/O或事件驱动模型可能更合适。