boost 单io_serverce 异步多线程资源保护代码

服务器：

// ConsoleApplication12.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <cstdlib>
#include <iostream>
#include <memory>
#include <utility>
#include <boost/asio.hpp>
#include <thread>
#include <boost/bind.hpp>
using boost::asio::ip::tcp;
#include<mutex>
std::mutex lock;
class session
	: public std::enable_shared_from_this < session >
{
public:
	session(tcp::socket socket)
		: socket_(std::move(socket))
	{
	}
	~session()
	{
		//std::cout << "~senssion" << std::endl;
	}
	void start()
	{
		do_read();
	}

private:
	void do_read()
	{
		//
		
		static long cnt = 0;
		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)
			{
				do_write(length);
			}
			//lock.lock();
			{
				std::unique_lock<std::mutex> l(lock);
				cnt++;
				std::this_thread::sleep_for(std::chrono::milliseconds(50));
				std::cout << "id=" << std::this_thread::get_id() <<"cnt="<<cnt<< std::endl;
				std::this_thread::sleep_for(std::chrono::milliseconds(100));
				cnt--;
			}
			
			//lock.unlock();
			
		});
		
	}

	void do_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)
			{
				do_read();
			}
		});
	}

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

class server
{
public:
	server(boost::asio::io_service& io_service, short port)
		: acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
		socket_(io_service)
	{
		do_accept();
	}

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

			do_accept();
		});
	}

	tcp::acceptor acceptor_;
	tcp::socket socket_;
};
boost::asio::io_service io_service;
int main1()
{
	try
	{
		
		

		server s(io_service, 8001);
		std::thread work1(boost::bind(&boost::asio::io_service::run, &io_service));
		std::thread work2(boost::bind(&boost::asio::io_service::run, &io_service));
		std::thread work3(boost::bind(&boost::asio::io_service::run, &io_service));
		std::thread work4(boost::bind(&boost::asio::io_service::run, &io_service));
		work1.join();
		work2.join();
		work3.join();
		work4.join();
	}
	catch (std::exception& e)
	{
		std::cerr << "Exception: " << e.what() << "\n";
	}

	return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
	main1();
	return 0;
}

测试客户端：

// async_Client.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <boost/asio.hpp>
#include <thread>
#include <boost/bind.hpp>
#include <boost\enable_shared_from_this.hpp>
#include <boost\noncopyable.hpp>
#include <boost\format.hpp>
#include <vector>
using namespace boost::asio;
#define MEM_FN(x)       boost::bind(&self_type::x, shared_from_this())
#define MEM_FN1(x,y)    boost::bind(&self_type::x, shared_from_this(),y)
#define MEM_FN2(x,y,z)  boost::bind(&self_type::x, shared_from_this(),y,z)
io_service service;
class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr>, boost::noncopyable {
	typedef talk_to_svr self_type;
	talk_to_svr(const std::string & message) : sock_(service), started_(true), message_(message) {}
	void start(ip::tcp::endpoint ep) {
		sock_.async_connect(ep, MEM_FN1(on_connect, _1));
	}
public:
	typedef boost::system::error_code error_code;
	typedef boost::shared_ptr<talk_to_svr> ptr;
	static ptr start(ip::tcp::endpoint ep, const std::string &message) {
		ptr new_(new talk_to_svr(message));
		new_->start(ep);
		return new_;
	}
	void stop() {
		if (!started_) return;
		started_ = false;
		sock_.close();
	}
	bool started() { return started_; }
	void do_read() {
		async_read(sock_, buffer(read_buffer_), MEM_FN2(read_complete, _1, _2), MEM_FN2(on_read, _1, _2));
	}
	void do_write(const std::string & msg) {
		if (!started()) return;
		std::copy(msg.begin(), msg.end(), write_buffer_);
		sock_.async_write_some(buffer(write_buffer_, msg.size()), MEM_FN2(on_write, _1, _2));
	}
	size_t read_complete(const boost::system::error_code & err, size_t bytes) {
		if (err) return 0;
		bool found = std::find(read_buffer_, read_buffer_ + bytes, '.') < read_buffer_ + bytes;
		// 我们一个一个读取直到读到回车，不缓存
		return found ? 0 : 1;
	}
	void on_connect(const error_code & err) {
		if (!err)      do_write(message_ + "\n");
		else            stop();
	}
	void on_read(const error_code & err, size_t bytes) {
		if (!err) {
			std::string copy(read_buffer_, bytes - 1);
			std::cout << "server echoed our " << message_ << ": " << (copy == message_ ? "OK" : "FAIL") << std::endl;
		}
		do_write(message_);
	}
	void on_write(const error_code & err, size_t bytes) {
		do_read();
	}
private:
	ip::tcp::socket sock_;
	enum { max_msg = 1024 };
	char read_buffer_[max_msg];
	char write_buffer_[max_msg];
	bool started_;
	std::string message_;
};
void test(ip::tcp::endpoint ep, const std::string &message)
{
	talk_to_svr::start(ep, message);
	service.run();
}
void sum() {
	std::cout << 3 << std::endl;
}


int _tmain(int argc, _TCHAR* argv[])
{
#define THREADNUM 100
	try{
		ip::tcp::endpoint e(ip::address::from_string("127.0.0.1"), 8001);
		boost::format fat("id= %1%.");
		std::vector<std::shared_ptr<std::thread>> ar;
		std::shared_ptr<std::thread> thread_ptr;
		for (int i = 0; i < THREADNUM; i++)
		{
			fat%i;
			thread_ptr = std::make_shared<std::thread>(boost::bind(test, e, fat.str()));
			ar.push_back(thread_ptr);
		}
		for (int i = 0; i < THREADNUM; i++)
		{
			ar[i]->join();
		}
	}
	catch (std::exception &e)
	{
	
	std::cout << e.what() << std::endl;
	}
	

	return 0;
}