mirror of
https://github.com/boostorg/asio.git
synced 2026-01-23 05:22:08 +00:00
d41d2d15e9
io_service.notify_fork() at the appropriate times. Two new examples have been added showing how to use this feature. Refs #3238, #4162. * Clean up the handling of errors reported by the close() system call. In particular, assume that most operating systems won't have close() fail with EWOULDBLOCK, but if it does then set blocking mode and restart the call. If any other error occurs we assume the descriptor is closed. Refs #3307. * EV_ONESHOT seems to cause problems on some versions of Mac OS X, with the io_service destructor getting stuck inside the close() system call. Use EV_CLEAR instead. Refs #5021. * Include function name in exception what() messages. * Fix insufficient initialisers warning with MinGW. * Make the shutdown_service() member functions private. * Add archetypes for testing socket option functions. * Add missing lock in signal_set_service::cancel(). * Fix copy/paste error in SignalHandler example. * The signal header needs to be included in signal_set_service.hpp so that we can use constants like NSIG and SIGRTMAX. * Don't use Boost.Thread's convenience header. Use the header file that is specifically for the boost::thread class instead. [SVN r69467]
72 lines
2.0 KiB
C++
72 lines
2.0 KiB
C++
//
|
|
// io_service_pool.cpp
|
|
// ~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
#include "server.hpp"
|
|
#include <stdexcept>
|
|
#include <boost/thread/thread.hpp>
|
|
#include <boost/bind.hpp>
|
|
#include <boost/shared_ptr.hpp>
|
|
|
|
namespace http {
|
|
namespace server2 {
|
|
|
|
io_service_pool::io_service_pool(std::size_t pool_size)
|
|
: next_io_service_(0)
|
|
{
|
|
if (pool_size == 0)
|
|
throw std::runtime_error("io_service_pool size is 0");
|
|
|
|
// Give all the io_services work to do so that their run() functions will not
|
|
// exit until they are explicitly stopped.
|
|
for (std::size_t i = 0; i < pool_size; ++i)
|
|
{
|
|
io_service_ptr io_service(new boost::asio::io_service);
|
|
work_ptr work(new boost::asio::io_service::work(*io_service));
|
|
io_services_.push_back(io_service);
|
|
work_.push_back(work);
|
|
}
|
|
}
|
|
|
|
void io_service_pool::run()
|
|
{
|
|
// Create a pool of threads to run all of the io_services.
|
|
std::vector<boost::shared_ptr<boost::thread> > threads;
|
|
for (std::size_t i = 0; i < io_services_.size(); ++i)
|
|
{
|
|
boost::shared_ptr<boost::thread> thread(new boost::thread(
|
|
boost::bind(&boost::asio::io_service::run, io_services_[i])));
|
|
threads.push_back(thread);
|
|
}
|
|
|
|
// Wait for all threads in the pool to exit.
|
|
for (std::size_t i = 0; i < threads.size(); ++i)
|
|
threads[i]->join();
|
|
}
|
|
|
|
void io_service_pool::stop()
|
|
{
|
|
// Explicitly stop all io_services.
|
|
for (std::size_t i = 0; i < io_services_.size(); ++i)
|
|
io_services_[i]->stop();
|
|
}
|
|
|
|
boost::asio::io_service& io_service_pool::get_io_service()
|
|
{
|
|
// Use a round-robin scheme to choose the next io_service to use.
|
|
boost::asio::io_service& io_service = *io_services_[next_io_service_];
|
|
++next_io_service_;
|
|
if (next_io_service_ == io_services_.size())
|
|
next_io_service_ = 0;
|
|
return io_service;
|
|
}
|
|
|
|
} // namespace server2
|
|
} // namespace http
|