asio fiber 异步实质，同步的写法
//mafeitao[at]gmail.com
// async_tcp_echo_server.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 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 "stdafx.h"
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include < boost/date_time/posix_time/posix_time.hpp>
#include < windows.h>
using boost::asio::ip::tcp;
#include <windows.h>
void * GetMainFiber(void)
{
static bool ini=false;
static void * mainFiber=NULL;
if(ini==false)
{
ini=true;
mainFiber= ConvertThreadToFiber(NULL);
}
assert(mainFiber !=NULL);
return mainFiber;
};
class CFiberSocket
{
private:
tcp::socket * pSocket_;
enum { max_length = 1024 };
char data_[max_length];
bool ok_;
int bytes_transferred_;
void * meFiber_;
public:
CFiberSocket(tcp::socket * socket)
:pSocket_(socket),
ok_(false)
{
bytes_transferred_=0;
meFiber_=::GetCurrentFiber();
};
~CFiberSocket(void)
{
pSocket_->close();
delete pSocket_;
::SwitchToFiber(GetMainFiber());
};
void close(void)
{
pSocket_->close();
};
std::string read_some(int max_length, int timeout)
{
pSocket_->async_read_some(boost::asio::buffer(data_, max_length),
boost::bind(&CFiberSocket::handle_read, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
SwitchToFiber(GetMainFiber());
if(ok_)
{
std::string str(data_, bytes_transferred_);
return str;
}
else
return "";
};
void handle_read(const boost::system::error_code& error,
size_t bytes_transferred)
{
bytes_transferred_ =bytes_transferred;
if (!error)
{
//没有错误
ok_=true;
}
else
{
//有错误
ok_=false;
}
SwitchToFiber(meFiber_);
};
bool write(const char * buf, int size)
{
boost::asio::async_write(*pSocket_,
boost::asio::buffer(buf, size),
boost::bind(&CFiberSocket::handle_write, this,
boost::asio::placeholders::error));
SwitchToFiber(GetMainFiber());
return ok_;
}
void handle_write(const boost::system::error_code& error)
{
if (!error)
{
ok_=true;
}
else
{
ok_=false;
}
SwitchToFiber(meFiber_);
};
};
//纤程内部，同步等待
void WINAPI sessionProc(void * pSocket)
{
CFiberSocket socket( (tcp::socket *) pSocket);
std::string str;
while(true)
{
str=socket.read_some(100,1);
printf("%s\n", str.c_str());
if(str.size()==0)
{
return;
};
char buf[100];
int * fiber=(int *) GetCurrentFiber();
sprintf(buf,"[%x]\r\n", fiber );
str.append(buf);
socket.write(str.c_str(), str.size());
};
};
class server
{
public:
server(boost::asio::io_service& io_service, short port)
: io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
tcp::socket * pSocket = new tcp::socket(io_service_);
acceptor_.async_accept(*pSocket,
boost::bind(&server::handle_accept, this, pSocket,
boost::asio::placeholders::error));
}
void handle_accept(tcp::socket * pSocket,
const boost::system::error_code& error)
{
if (!error)
{
void * me = CreateFiber(4096, sessionProc, pSocket);
::SwitchToFiber(me);
tcp::socket * pNewSocket = new tcp::socket(io_service_);
acceptor_.async_accept(*pNewSocket,
boost::bind(&server::handle_accept, this, pNewSocket,
boost::asio::placeholders::error));
}
else
{
assert(true==false);
}
}
private:
boost::asio::io_service& io_service_;
tcp::acceptor acceptor_;
};
int main(int argc, char* argv[])
{
try
{
char* pPort="1235";
if (argc != 2)
{
std::cerr << "Usage: echo_server
\n";}
else
{
pPort=argv[1];
}
boost::asio::io_service io_service;
GetMainFiber();
using namespace std; // For atoi.
server s(io_service, atoi(pPort));
io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
asio fiber 例子， 把asio异步非阻塞的调用，借助fiber 纤程[协程]， 构造语法糖，包装为同步阻塞的写法。
注意这个函数
//纤程内部，同步等待
void WINAPI sessionProc(void * pSocket)
函数里面是阻塞调用的写法，但是通过纤程跳到主纤程里面，在主纤程的回调函数里，又跳回到该会话的纤程。
客户端一个连接，对应于服务器端的一个socket, 每个socket新开一个纤程， 每个线程是一个会话，纤程sessionProc里收发是同步的写法。
有时间再把异步accept包装为同步写法，为linux也做一个asio + 纤程的版本