#include <stdio.h>

 #include <cstdlib>

 #include <iostream>

 #include <boost/thread.hpp>

 #include <boost/aligned_storage.hpp>

 #include <boost/array.hpp>

 #include <boost/bind.hpp>

 #include <boost/enable_shared_from_this.hpp>

 #include <boost/noncopyable.hpp>

 #include <boost/shared_ptr.hpp>

 #include <boost/asio.hpp> 

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

 class handler_allocator

     : private boost::noncopyable

 {

 public:

     handler_allocator()

         : in_use_(false)

     {

     }

     void* allocate(std::size_t size)

     {

         if (!in_use_ && size < storage_.size)

         {

             in_use_ = true;

             return storage_.address();

         }

         else

         {

             return ::operator new(size);

         }

     }

     void deallocate(void* pointer)

     {

         if (pointer == storage_.address())

         {

             in_use_ = false;

         }

         else

         {

             ::operator delete(pointer);

         }

     }

 private:

     // Storage space used for handler-based custom memory allocation.

     boost::aligned_storage<> storage_;

     // Whether the handler-based custom allocation storage has been used.

     bool in_use_;

 };

 template <typename Handler>

 class custom_alloc_handler

 {

 public:

     custom_alloc_handler(handler_allocator& a, Handler h)

         : allocator_(a),

         handler_(h)

     {

     }

     template <typename Arg1>

     void operator()(Arg1 arg1)

     {

         handler_(arg1);

     }

     template <typename Arg1, typename Arg2>

     void operator()(Arg1 arg1, Arg2 arg2)

     {

         handler_(arg1, arg2);

     }

     friend void* asio_handler_allocate(std::size_t size,

         custom_alloc_handler<Handler>* this_handler)

     {

         return this_handler->allocator_.allocate(size);

     }

     friend void asio_handler_deallocate(void* pointer, std::size_t /*size*/,

         custom_alloc_handler<Handler>* this_handler)

     {

         this_handler->allocator_.deallocate(pointer);

     }

 private:

     handler_allocator & allocator_;

     Handler handler_;

 };

 // Helper function to wrap a handler object to add custom allocation.

 template <typename Handler>

 inline custom_alloc_handler<Handler> make_custom_alloc_handler(

     handler_allocator& a, Handler h)

 {

     return custom_alloc_handler<Handler>(a, h);

 }

 /// A pool of io_service objects.

 class io_service_pool

     : private boost::noncopyable

 {

 public:

     /// Construct the io_service pool.

     explicit io_service_pool(std::size_t pool_size) : next_io_service_()

     {

         if (pool_size == )

             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 = ; 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);

         }

     }

     // Run all io_service objects in the pool.

     void 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 = ; 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 = ; i < threads.size(); ++i)

             threads[i]->join();

     }

     // Stop all io_service objects in the pool.

     void stop()

     {

         // Explicitly stop all io_services.

         for (std::size_t i = ; i < io_services_.size(); ++i)

             io_services_[i]->stop();

     }

     // Get an io_service to use.

     boost::asio::io_service& 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_ = ;

         return io_service;

     }

 private:

     typedef boost::shared_ptr<boost::asio::io_service> io_service_ptr;

     typedef boost::shared_ptr<boost::asio::io_service::work> work_ptr;

     /// The pool of io_services.

     std::vector<io_service_ptr> io_services_;

     /// The work that keeps the io_services running.

     std::vector<work_ptr> work_;

     /// The next io_service to use for a connection.

     std::size_t next_io_service_;

 };

 class session

     : public boost::enable_shared_from_this<session>

 {

 public:

     session(boost::asio::io_service& work_service

         , boost::asio::io_service& io_service)

         : socket_(io_service)

         , io_work_service(work_service)

     {

     }

     tcp::socket& socket()

     {

         return socket_;

     }

     void start()

     {

         boost::system::error_code error;

         handle_write(error);

         socket_.async_read_some(boost::asio::buffer(data_),

             make_custom_alloc_handler(allocator_,

                 boost::bind(&session::handle_read,

                     shared_from_this(),

                     boost::asio::placeholders::error,

                     boost::asio::placeholders::bytes_transferred)));

     }

     void handle_read(const boost::system::error_code& error,

         size_t bytes_transferred)

     {

         if (!error)

         {

             boost::shared_ptr<std::vector<char> > buf(new std::vector<char>);

             buf->resize(bytes_transferred);

             std::copy(data_.begin(), data_.begin() + bytes_transferred, buf->begin());

             io_work_service.post(boost::bind(&session::on_receive

                 , shared_from_this(), buf, bytes_transferred));

             socket_.async_read_some(boost::asio::buffer(data_),

                 make_custom_alloc_handler(allocator_,

                     boost::bind(&session::handle_read,

                         shared_from_this(),

                         boost::asio::placeholders::error,

                         boost::asio::placeholders::bytes_transferred)));

         }

     }

     void handle_write(const boost::system::error_code& error)

     {

         if (!error)

         {

             char notice[] = "Welcome to Connect to Hiper Service";

             size_t num;

             try

             {

                 num = socket_.send(boost::asio::buffer(notice));

             }

             catch (std::exception &e)

             {

                 std::cout << "exception: " << e.what() << std::endl;

             }

             if (num>)

             {

                 std::cout << "send : " << notice << std::endl;

             }

         }

     }

     void on_receive(boost::shared_ptr<std::vector<char> > buffers

         , size_t bytes_transferred)

     {

         char* data_stream = &(*buffers->begin());

         // in here finish the work.

         std::cout << "receive :" << bytes_transferred << " bytes." <<

             "message :" << data_stream << std::endl;

         boost::system::error_code error;

         handle_write(error);

     }

 private:

     // The io_service used to finish the work.

     boost::asio::io_service& io_work_service;

     // The socket used to communicate with the client.

     tcp::socket socket_;

     // Buffer used to store data received from the client.

     boost::array<char, > data_;

     // The allocator to use for handler-based custom memory allocation.

     handler_allocator allocator_;

 };

 typedef boost::shared_ptr<session> session_ptr;

 class server

 {

 public:

     server(short port, std::size_t io_service_pool_size)

         : io_service_pool_(io_service_pool_size)

         , io_service_work_pool_(io_service_pool_size)

         , acceptor_(io_service_pool_.get_io_service(), tcp::endpoint(tcp::v4(), port))

     {

         session_ptr new_session(new session(io_service_work_pool_.get_io_service()

             , io_service_pool_.get_io_service()));

         acceptor_.async_accept(new_session->socket(),

             boost::bind(&server::handle_accept, this, new_session,

                 boost::asio::placeholders::error));

     }

     void handle_accept(session_ptr new_session,

         const boost::system::error_code& error)

     {

         if (!error)

         {

             new_session->start();

             new_session.reset(new session(io_service_work_pool_.get_io_service()

                 , io_service_pool_.get_io_service()));

             acceptor_.async_accept(new_session->socket(),

                 boost::bind(&server::handle_accept, this, new_session,

                     boost::asio::placeholders::error));

         }

     }

     void run()

     {

         io_thread_.reset(new boost::thread(boost::bind(&io_service_pool::run

             , &io_service_pool_)));

         work_thread_.reset(new boost::thread(boost::bind(&io_service_pool::run

             , &io_service_work_pool_)));

     }

     void stop()

     {

         io_service_pool_.stop();

         io_service_work_pool_.stop();

         io_thread_->join();

         work_thread_->join();

     }

 private:

     boost::shared_ptr<boost::thread> io_thread_;

     boost::shared_ptr<boost::thread> work_thread_;

     io_service_pool io_service_pool_;

     io_service_pool io_service_work_pool_;

     tcp::acceptor acceptor_;

 };

 int main() {

     server svr(, );

     svr.run();

     while (true)

     {

         boost::this_thread::sleep(boost::posix_time::seconds());

     }

     return ;

 }

 #include <iostream>

 #include <boost/shared_ptr.hpp>

 #include <boost/asio.hpp>

 #include <boost/asio/placeholders.hpp>

 #include <boost/system/error_code.hpp>

 #include <boost/bind/bind.hpp>

 #include<boost/thread.hpp>

 using namespace boost::asio;

 using namespace std;

 class client

 {

     typedef client this_type;

     typedef ip::tcp::acceptor acceptor_type;

     typedef ip::tcp::endpoint endpoint_type;

     typedef ip::tcp::socket socket_type;

     typedef ip::address address_type;

     typedef boost::shared_ptr<socket_type> sock_ptr;

     typedef vector<char> buffer_type;

 private:

     io_service m_io;

     buffer_type m_buf;

     endpoint_type m_ep;

 public:

     client() : m_buf(, ), m_ep(address_type::from_string("127.0.0.1"), )

     {

         start();

     }

     void run()

     {

         m_io.run();

     }

     void start()

     {

         sock_ptr sock(new socket_type(m_io));

         sock->async_connect(m_ep, boost::bind(&this_type::conn_handler, this, boost::asio::placeholders::error, sock));

     }

     void conn_handler(const boost::system::error_code&ec, sock_ptr sock)

     {

         if (ec)

         {

             std::cout << ec.message() << std::endl;

             return;

         }

         cout << "Receive from " << sock->remote_endpoint().address() << ": ";

         cout << "Port:" << sock->remote_endpoint().port() << endl;

         sock->async_read_some(buffer(m_buf), boost::bind(&client::read_handler, this, boost::asio::placeholders::error, sock));

     }

     void read_handler(const boost::system::error_code&ec, sock_ptr sock)

     {

         if (ec)

         {

             return;

         }

         sock->async_read_some(buffer(m_buf), boost::bind(&client::read_handler, this, boost::asio::placeholders::error, sock));

         cout << &m_buf[] << endl;

         boost::this_thread::sleep(boost::posix_time::milliseconds());

         char pmsg[] = "client 6666";

         sock->async_write_some(buffer(pmsg), boost::bind(&this_type::write_handler, this, boost::asio::placeholders::error));

     }

     void write_handler(const boost::system::error_code& ec)

     {

         if (ec)

         {

             std::cout << ec.message() << std::endl;

             return;

         }

         std::cout << "send success!" << std::endl;

     }

 };

 int main()

 {

     try

     {

         cout << "Client start." << endl;

         client cl;

         cl.run();

     }

     catch (std::exception &e)

     {

         cout << e.what() << endl;

     }

     while (true)

     {

         boost::this_thread::sleep(boost::posix_time::seconds());

     }

     return ;

 }