我正在编写一个高效的套接字服务器。意图是良好的整体吞吐量。我使用主线程作为监听器。它async_accept一个客户端并将套接字添加到队列中。有一个调度程序线程从队列中获取一个准备好从中读取的套接字并添加到一个工作线程的队列中。我保留了一堆工作线程。工作线程将进行实际读/写。
我在听众中使用async_accept。要找出哪个套接字可以读取，我在我的调度程序中使用async_read_some。这个想法有效，但有问题。我的io_service.run()在侦听器中被调用，因此调度程序中async_read_some的处理程序实际上是在侦听器线程中运行的。
这是我的代码：
using boost::asio::ip::tcp;
using namespace std;
std::queue<std::shared_ptr<tcp::socket>> q_sock;
boost::mutex m_log1;
boost::condition_variable m_cond1;
boost::mutex::scoped_lock m_lock1 = boost::mutex::scoped_lock(m_log1);
sem_t _sem_sock;
enum { max_length1 = 1024 };
char data_1[max_length1];
void handle_read1(std::shared_ptr<tcp::socket> sock, const boost::system::error_code& error,
size_t bytes_transferred)
{
printf("handle_read1 : error : %s : %d, thread id is: %ld, pid : %d \n", error.category().name(), error.value(), (long int)syscall(SYS_gettid), getpid());
boost::asio::write(*(sock.get()), boost::asio::buffer(data_1, bytes_transferred));
}
void sock_dispatch() {
int v_size = 0;
std::shared_ptr<tcp::socket> curr_sock;
printf("sock_dispatch started. The ID of this of this thread is: %ld, pid : %d \n", (long int)syscall(SYS_gettid), getpid());
while(1) {
while(1) {
sem_wait(&_sem_sock);
v_size = q_sock.size();
sem_post(&_sem_sock);
if(v_size <= 0)
m_cond1.timed_wait(m_lock1,boost::posix_time::milliseconds(5000));
else
break;
}
sem_wait(&_sem_sock);
curr_sock = q_sock.front();
q_sock.pop();
sem_post(&_sem_sock);
curr_sock->async_read_some(boost::asio::buffer(data_1, max_length1),
boost::bind(handle_read1, curr_sock,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
}
class session
{
public:
session(boost::asio::io_service& io_service)
: sockptr(new tcp::socket(io_service)) {}
void start()
{
printf("START NEW SESSION The ID of this of this thread is: %ld, pid : %d \n", (long int)syscall(SYS_gettid), getpid());
sem_wait(&_sem_sock);
q_sock.push(sockptr);
sem_post(&_sem_sock);
m_cond1.notify_all();
}
std::shared_ptr<tcp::socket> sockptr;
};
class server
{
public:
server(boost::asio::io_service& io_service, short port)
: io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
session* new_session = new session(io_service_);
acceptor_.async_accept(*(new_session->sockptr.get()),
boost::bind(&server::handle_accept, this, new_session,
boost::asio::placeholders::error));
printf("WAITING TO ACCEPT: The ID of this of this thread is: %ld, pid : %d \n", (long int)syscall(SYS_gettid), getpid());
}
void handle_accept(session* new_session,
const boost::system::error_code& error)
{
new_session->start();
new_session = new session(io_service_);
acceptor_.async_accept(*(new_session->sockptr.get()),
boost::bind(&server::handle_accept, this, new_session,
boost::asio::placeholders::error));
}
private:
boost::asio::io_service& io_service_;
tcp::acceptor acceptor_;
};
int main(int argc, char* argv[])
{
sem_init(&_sem_sock, 0, 1);
boost::asio::io_service io_service;
using namespace std;
server s(io_service, atoi(argv[1]));
boost::thread t(boost::bind(sock_dispatch));
io_service.run();
return 0;
}
此代码是从boost :: asio示例http://www.boost.org/doc/libs/1_39_0/doc/html/boost_asio/example/echo/async_tcp_echo_server.cpp修改的。客户端代码为http://www.boost.org/doc/libs/1_39_0/doc/html/boost_asio/example/echo/blocking_tcp_echo_client.cpp。
当客户端连接时，服务器的输出：
WAITING TO ACCEPT: The ID of this of this thread is: 3843, pid : 3843
sock_dispatch started. The ID of this of this thread is: 3844, pid : 3843
START NEW SESSION The ID of this of this thread is: 3843, pid : 3843
handle_read1 : error : system : 0, thread id is: 3843, pid : 3843
在这种情况下，调度程序线程标识为3944，但handle_read1在线程3843中运行。 理想情况下，handle_read1应该在调度程序中运行，因此它不会在侦听器中阻止接受。
知道我该怎么做才能实现这个目标吗？或者整个事情都有更好的设计:)？
答案 0 :(得分：2)
如果需要在特定线程中调用特定处理程序，则使用不同的io_service对象。例如，acceptor可以使用io_service1构建，套接字可以使用io_service2构建。然后主线程可以执行io_service1.run()，而线程池中的线程执行io_service2.run()。
话虽如此，混合异步和同步功能可能相当棘手。在我工作的大多数异步程序中，很少需要将线程专用于特定的异步链。
总的来说，我认为概念设计很好，但我对实施提出了一些建议：
q_sock消费者和生产者代码是更高级别和更低级别构造的混合。条件变量的使用有点不同寻常，并且提出了为什么sem_t被用来代替boost::mutex和锁定的问题。例如，以下消费者和生产者代码：
// Consumer
while(1)
{
sem_wait(&_sem_sock);
v_size = q_sock.size();
sem_post(&_sem_sock);
if (v_size <= 0)
m_cond1.timed_wait(m_lock1, boost::posix_time::milliseconds(5000));
else
break;
}
sem_wait(&_sem_sock);
curr_sock = q_sock.front();
q_sock.pop();
sem_post(&_sem_sock);
// Producer
sem_wait(&_sem_sock);
q_sock.push(sockptr);
sem_post(&_sem_sock);
m_cond1.notify_all();
可以在不使用sem_t的情况下重写，并且可以根据Boost.Thread的condition_variable文档更加惯用。考虑替代方案：
// Consumer
boost::unique_lock<boost::mutex> lock(m_log1);
while (q_sock.empty())
{
m_cond1.wait(lock);
}
curr_sock = q_sock.front();
q_sock.pop();
lock.unlock();
// Producer
{
boost::lock_guard<boost::mutex> lock(m_log1);
q_sock.push(sockptr);
}
m_cond1.notify_all();
目前尚不清楚session提供的功能。
session::sockptr通过智能指针进行管理，但session不是。如果session未通过智能指针进行管理，则server::handle_accept会发生内存泄漏，因为重新分配时session的句柄会丢失。确定要提供的功能session，并围绕该功能设计界面。
handle_read1）可能需要成为成员函数。session有自己的异步链，并且正在向处理程序提供，那么请考虑使用enable_shared_from_this。 Boost.Asio tutorial提供了一个示例用法，与examples中的一些用法一样。目前，async_read_some未指示哪个套接字已准备好被读取。到调用ReadHandler时，已读取数据。
这是Proactor和Reactor之间的根本区别。如果您需要Reactor样式操作，请使用boost::asio::null_buffers。有关详细信息，请参阅this文档。但是，每种方法都会产生影响。因此，了解这些后果至关重要，以便做出最佳决策。
Boost.Asio通过高级构造提供事件解复用，sock_dispatch线程似乎不切实际。 session::start成员函数可以启动套接字上的异步读取。这个小的改动将消除q_sock的需要，以及示例代码中的所有同步构造。
检查必须使用同步写入的原因。对于echo客户端，如示例所示，通常可以通过控制异步链本身的流来消除资源争用来使用异步写入。这允许每个连接都有自己的缓冲区，可以用于读写。