服务器:
// 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;
}