国产免费成人av,亚洲激情在线观看,99在线精品观看

Tue, 01 Jan 2013 05:14:00 GMT

协程

协程�Q�即协作式程序，其思想是，一�p�d��互相依赖的协�E�间依次使用CPU�Q�每�ơ只有一个协�E�工作，而其他协�E�处于休眠状态。协�E�可以在�q�行期间的某个点上暂停执行，�q�在恢复�q�行时从暂停的点上��l�执行�?协程已经被证明是一�U�非常有用的�E�序�l��g�Q�不仅被python、lua、ruby�{�脚本语�a��q�泛采用�Q�而且被新一代面向多核的�~�程语言如golang rust-lang�{�采用作为�ƈ发的基本单位�?协程可以被认为是一�U�用��L(f��ng)��间线�E�，与传�l�的�U�程相比�Q�有2个主要的优点�Q?/p>

与线�E�不同，协程是自�׃��动让出CPU�Q��ƈ交付他期望的下一个协�E�运行，而不是在��M��时候都有可能被�pȝ��调度打断。因此协�E�的使用更加清晰易懂�Q��ƈ且多数情况下不需要锁机制�?/li>
与线�E�相比，协程的切换由�E�序控制�Q�发生在用户�I�间而非内核�I�间�Q�因此切换的代�h(hu��n)非常��?/li>

�|�络�~�程模型

首先来简单回��一下一些常用的�|�络�~�程模型。网�l�编�E�模型可以大体的分�ؓ(f��)同步模型和异步模型两�c�R�?/p>

同步模型�Q?/li>

同步模型使用��d��IO模式,在阻塞IO模式下调用read�{�IO函数时会(x��)��d��U�程直到IO完成或失败�?/p>

同步模型的典型代表是thread per connection模型�Q�每当阻塞在�ȝ��E�上的accept调用�q�回时则创徏一个新的线�E�去服务于新的socket的读/写。这�U�模型的优点是程序简�z�，�~�写��单；�~�点是可伸羃性收到线�E�数的限�Ӟ��当连接越来越多时�Q�线�E�也��来��多�Q�频�J�的�U�程切换�?x��)严重拖累性能�?/p>

异步模型�Q?/li>

异步模型一般��用非��d��IO模式�Q��ƈ配合epoll/select/poll�{�多路复用机制。在非阻塞模式下调用read�Q�如果没有数据可��d��立即�q�回�q��知用户没有可读�Q�EAGAIN/EWOULDBLOCK�Q�，而非��d��当前�U�程。异步模型可以��一个线�E�同时服务于多个IO对象�?/p>

异步模型的典型代表是reactor模型。在reactor模型中，我们��所有要处理的IO事�g注册��C��个中心的IO多�\复用器中�Q�一般�ؓ(f��)epoll/select/poll�Q�，同时�ȝ��E�阻塞在多�\复用器上。一旦有IO事�g到来或者就�l�，多�\复用器返回�ƈ��对应的IO事�g分发到对应的处理器（卛_��调函敎ͼ�中，最后处理器调用read/write函数来进行IO操作�?/p>

异步模型的特�Ҏ(gu��)��性能和可伸羃性比同步模型要好很多�Q�但是其�l�构复杂�Q�不易于�~�写和维护。在异步模型中，IO之前的代码（IO��d��的提交者）和IO之后的处理代码（回调函数�Q�是割裂开来的�?/p>

协程与网�l�编�E?/h3>
协程为克服同步模型和异步模型的缺点，�q�结合他们的优点提供了可能：(x��) 现在假设我们�?个协�E�A,B,C分别要进行数�ơIO操作。这3个协�E�运行在同一个调度器或者说�U�程的上下文中，�q�依�ơ��用CPU。调度器在其内部�l�护了一个多路复用器�Q�epoll/select/poll�Q��?/p>
协程A首先�q�行�Q�当它执行到一个IO操作�Q�但该IO操作�q�没有立卛_��l�时�Q�A��该IO事�g注册到调度器中，�q�主动放弃CPU。这时调度器��B切换到CPU上开始执行，同样�Q�当它碰��C��个IO操作的时候将IO事�g注册到调度器中，�q�主动放弃CPU。调度器��C切换到cpu上开始执行。当所有协�E�都�?#8220;��d��”后，调度器检查注册的IO事�g是否发生或就�l�。假设此时协�E�B注册的IO旉��已经��q�A�Q�调度器��恢复B的执行，B��从上次攑ּ�CPU的地�Ҏ(gu��)��着向下�q�行。A和C同理�?/p>
�q�样�Q�对于每一个协�E�来��_(d��)��是同步的模型�Q�但是对于整个应用程序来��_(d��)��却是异步的模型�?/p>
好了�Q�原理说完了�Q�我们来看一个实际的例子�Q�echo server�?/p>

echo server

在这个例子中�Q�我们将使用orchid库来�~�写一个echo server�?a rel="nofollow" style="padding: 0px; margin: 0px; color: #4466bb; outline: 0px;">orchid库是一个构��Z��boost基础上的协程/�|�络IO 库�?/p>

echo server首先必须要处理连接事�Ӟ��我们创徏一个协�E�来专门处理�q�接事�g�Q?/p>

typedef boost::shared_ptr socket_ptr; 
//处理ACCEPT事�g的协�E?
void handle_accept(orchid::coroutine_handle co) {
     try {         
         orchid::acceptor acceptor(co -> get_scheduler().get_io_service());//构徏一个acceptor
         acceptor.bind_and_listen("5678",true);         
         for(;;) {             
            socket_ptr sock(new orchid::socket(co -> get_scheduler().get_io_service()));
            acceptor.accept(*sock,co);             
            //在调度器上创��Z��个协�E�来服务新的socket�?/span>�W�一个参数是要创建的协程的main函数�Q?/span>�W�二个参数是要创建的协程的栈的大����?/span>
            co -> get_scheduler().spawn(boost::bind(handle_io,_1,sock),orchid::minimum_stack_size());
         }
     } catch(boost::system::system_error& e) {
            cerr<     } 
}

在orchid中，协程的main函数必须满��函数�{�֐�void(orchid::coroutine_handle)�Q�如handle_accept所�C�，其中参数co是协�E�句柄，代表了当前函数所位于的协�E��?/p>

在上面的代码中，我们创徏了一个acceptor�Q��ƈ让它监听5678端口�Q�然后在"��d��"�{�待�q�接到来�Q�当�q�接事�g到来�Ӟ��创徏一个新的协�E�来服务新的socket。处理套接字IO的协�E�如下：(x��)

//处理SOCKET IO事�g的协�E?
void handle_io(orchid::coroutine_handle co,socket_ptr sock) {     
   orchid::tcp_ostream out(*sock,co);     
   orchid::tcp_istream in(*sock,co);     
   for(std::string str;std::getline(in, str) && out;) {
      out<   }  
}

IO处理协程首先在传入的套接字上创徏了一个输入流和一个输出流�Q�分别代表了TCP的输入和输出。然后不断地从输入流中读取一行，�q�输出到输出��当中。当socket上的TCP�q�接断开�Ӟ��输入��和输出��的eof标志��Z��(x��)被置位，因此循环�l�束�Q�协�E�退出�?/p>

orchid可以使用户以��的形式来操作套接字。输入流和输出流分别提供了std::istream和std::ostream的接口；输入��和输出��是带缓冲的�Q�如果用户需要无�~�冲的读写socket或者自建缓�Ԍ��可以直接调用orchid::socket的read和write函数。但是需要注意这两个函数�?x��)抛出boost::system_error异常来表�C�错误�?/p>

�l�心的读者可能已�l�发玎ͼ�handle_io的函数签名�ƈ不满��void(orchid::coroutine_handle)�Q�回到handle_accept中，可以发现�Q�实际上我们使用了boost.bind对handle _ io函数�q�行了适配�Q��之符合函数签名的要求�?/p>

最后是main函数�Q?/p>

int main() {     
   orchid::scheduler sche;     
   sche.spawn(handle_accept,orchid::coroutine::minimum_stack_size());//创徏协程     
   sche.run(); 
}

在上面这个echo server的例子中�Q�我们采用了一�U?coroutine per connection 的编�E�模型，与传�l�的 thread per connection 模型一��L(f��ng)��z�清晎ͼ�但是整个�E�序实际上运行在同一�U�程当中�?/p>

�׃��协程的切换开销�q�远��于�U�程�Q�因此我们可以轻易的同时启动上千协程来同时服务上千连接，�q�是 thread per connection的模型很隑ց�到的�Q�在性能斚w��Q�整个底层的IO�pȝ��实际上是使用boost.asio�q�种高性能的异步io库实现的。而且与IO所费的旉��相比�Q�协�E�切换的开销基本可以忽略�?/p>

因此通过协程�Q�我们可以在保持同步IO模型��z�性的同时�Q�获得近��g��异步IO模型的高性能�?/p>

江浸�?/a> 2013-01-01 13:14 发表评论

Sun, 27 Nov 2011 21:17:00 GMT

转蝲��h��明出处。谢�?/span>

C++11中有很多�Ȁ动�h心的�Ҏ(gu��)�?但是相应的��得C++更加复杂。。�?br />新标准还修改了原有标准库�Q��ƈ增加了很多内宏V�?br />
在学�?f��n)新标准的过�E�中动手写了�?为std::tuple增加格式�?序列化能力的一��段代码

#define DECLARE_TUPLE_SERIALIZATION_FUNCTION(FUNC_NAME,BEG,SEP,END)     \
namespace sjdfsjfyttsaihfah6755jsdf554433356sdf{                        \
template <typename Tuple,std::size_t N>                                 \
struct tuple_printer                                                    \
{                                                                       \
    static void print(std::ostream& os,const Tuple& t)                  \
    {                                                                   \
        os<<std::get<std::tuple_size<Tuple>::value - N >(t)<<SEP;       \
        tuple_printer<Tuple,N-1>::print(os,t);                          \
    }                                                                   \
};                                                                      \
                                                                        \
template <typename Tuple>                                               \
struct tuple_printer<Tuple,1>                                           \
{                                                                       \
    static void print(std::ostream& os,const Tuple& t)                  \
    {                                                                   \
        os<<std::get<std::tuple_size<Tuple>::value-1>(t);               \
    }                                                                   \
};                                                                      \
}                                                                       \
template <typename Tuple>                                               \
void FUNC_NAME(std::ostream& os,const Tuple& t)                         \
{                                                                       \
    os<<BEG;                                                            \
    sjdfsjfyttsaihfah6755jsdf554433356sdf::tuple_printer<Tuple,std::tuple_size<Tuple>::value>::print(os,t);    \
    os<<END;                                                            \
}

实现成宏是�ؓ(f��)了��用�v来更方便�Q�可以随意指�?函数�?前缀分隔�W?�?后缀�?br />使用�Ҏ(gu��)��如下�Q?br />

DECLARE_TUPLE_SERIALIZATION_FUNCTION(serialize_tuple,"<"," , ",">")

int main()
{
    int i=10;
    auto a = std::make_tuple(3,"lala",i,'c');
    serialize_tuple(std::cout,a);
}

输出为：(x��)
<3 , "lala" , 10 , c>

��试环境为GCC 4.5�Q�注意编译时候请打开C++0X支持�?br />

江浸�?/a> 2011-11-28 05:17 发表评论

Sat, 13 Aug 2011 13:38:00 GMT

题目二：(x��)
题目我做了下改变�Q��用了上篇文章中提到的那个�c�X�Q�代码如下：(x��)

1 class X
2 {
3 public:
4     X(){cout<<"default construct"<<endl;}
5     X(int a):i(a){ cout<<"construct "<<i<<endl;}
6     ~X(){ cout<<"desconstruct "<<i<<endl;}
7     X(const X& x):i(x.i)
8     {
9         cout<<"copy construct "<<i<<endl;
10     }
11     X& operator++()
12     {
13         cout<<"operator ++(pre) "<<i<<endl;
14         ++i;
15         return *this;
16     }
17     const X operator++(int)
18     {
19         cout<<"operator ++(post) "<<i<<endl;
20         X x(*this);
21         ++i;
22         return x;
23     }
24     X& operator=(int m)
25     {
26         cout<<"operator =(int)"<<endl;
27         i = m;
28         return *this;
29     }
30     X& operator=(const X& x)
31     {
32         cout<<"operator =(X)"<<endl;
33         i=x.i;
34         return *this;
35     }
36     /////////////////////////
37     friend ostream& operator<<(ostream& os,const X& x)
38     {
39         os<<x.i;
40         return os;
41     }
42     friend X operator+(const X& a,const X& b)
43     {
44         cout<<"operator +"<<endl;
45         return X(a.i+b.i);
46     }
47     //////////////////////////
48 public:
49     int i;
50 };

请问以下代码的输出是什么？

1 X a(10),b(20);
2 X c=a+b;

我们来看一下��用GCC4.5�Q�默认编译选项�Q�以及MSVC9.0(BOTH DEBUG AND RELEASE)�~�译后的实际�q�行�l�果�Q?br />

construct 10

construct 20

operator +

construct 30

desconstruct 30

desconstruct 20

desconstruct 10

��单分析下�q�个输出�Q?br />

construct 10

construct 20 //对应 X a(10),b(20);

operator + //调用“+”操作�W?/div>

construct 30 //调用X(int){...}�Q?4行处

desconstruct 30 //变量c 的析�?/div>

desconstruct 20 //变量b 的析�?/div>

desconstruct 10 //变量a 的析�?/div>

从结果可以看出，整个执行�q�程中没有输�?#8220;operator=”�Q�说明压�Ҏ(gu��)��有调�?#8220;�Q?#8221;操作�W�，而且整个�q�程比我惌��的要��z�高效，没有临时对象�Q�没有拷贝构造�?br />�l�果��Z��么会(x��)是这样呢�Q�这主要归功于编译器的返回��g��化的能力�?br />有关�q�回��g��化的知识�Q�限于篇�q�我��׃��仔细介绍了，但是需要特别指出的是MSVC9.0只在RELEASE模式下默认开启NRVO�Q�即对具名对象的�q�回��g��化，以及�q�回��g��化里面的一个重要的�l�节�Q�体现在本例里就是：(x��)��Z��么中整个输出中没有出�?opeartor=",即�ؓ(f��)什么没调用"="操作�W��?br />
现在我们��代码稍微改变一下，�Ҏ(gu��)��下面的样�?

X a(10),b(20),c;
c=a+b; �Q�／�q�里我们��c的构造和赋值分开�?/span>

执行的结果如下：(x��)

construct 10 �Q�／构造a

construct 20 �Q�／构造b

default construct �Q�／构�?c

operator + �Q�／调用“+”操作�W?/div>

construct 30 �Q�／调用X(int){...}�Q?4行处

operator =(X) �Q�／调用“�Q?#8221;操作�W?/div>

desconstruct 30 �Q�／代码45行所建立的��(f��)时对象的析构

desconstruct 30 �Q�／变量c的析�?/div>

desconstruct 20 �Q�／变量b的析�?/div>

desconstruct 10 �Q�／变量c的析�?br />
�Ҏ(gu��)��前后的输出结果，可以发现多出以下三行

default construct

operator =(X)

desconstruct 30
出现�q�种差异的原因在于：(x��)

定义c的时候会(x��)调用默认的构造函数进行初始化�Q�因此第一条语句执行完之后�Q�c已经是一个存在的对象�Q�所以第二条语句�q�没有权利去直接修改c的内容，必须要通过调用赋值操作符”=“�Q�因此必��要产生一个��(f��)时对象。而在�W�一个例子中�Q�因为执行到�W�二条语句之前c�q�没有被创徏,所以编译器可以��?表达式a+b的返回值直接构建在c的内存中�Q�从而优化掉临时对象和对“�Q?#8221;的调用�?br />

江浸�?/a> 2011-08-13 21:38 发表评论

Sat, 13 Aug 2011 09:30:00 GMT

今年要开始找工作了，本着�U�篏�l�验的目的，跑去做了下MTK的笔试题�Q�笔试的内容主要是C�Q�＋�?br />因�ؓ(f��)开发中一直��用C�Q�＋�Q�而且对C�Q�＋里的高��Ҏ(gu��)��：(x��)面向对象�Q�模板等都比较熟�(zh��n)�，�q�没事喜�Ƣ研�I�下STL�Q�BOOST�Q�所以对自己的C�Q�＋水��^比较自信�Q�因此事先也没做��M��准备�Q�就直接�ȝ��试了。本来笔试完了后觉得题目蛮简单的�Q�但是本着认真学习(f��n)的态度回来后把题目都上��验了下，�l�果一下就�(zh��n)�剧了，错的体无完服啊。。�?br />�ȝ��了一下：(x��)
1。认真对待，不要��看了笔试题目：(x��)做题的时候心惌��些笔试题目都很简单啊�Q�很多题目都是扫了一眼就立即写出了答案，�l�果回来后才发现�q�些题目都设�|�了陷阱�Q�让你掉�q�去��出不来了�?br /> 2。C�Q�＋基础不够扎实。枉我还一天到晚的研究C�Q�＋的高�U�特性，�l�果很多基础的知识却都是一知半解�?br />特将此次�W�试的一些心得和体会(x��)记录于此�Q�好提醒自己。下面主要分析几个我做错的题目。题目�ƈ非与原题完全一致�?br />题目一�Q?br />

int a=10,b=6;
cout<<a+b<<" "<<a++<<" "<<b++;

误��Z��q�语句的执行�l�果�?br />很多人看�q�这�D�代码后估计都会(x��)直接��写上了 16 10 6 �q�样的结果吧�Q�但上机实验的输出结果是�Q?18 10 6
��Z��么会(x��)出现�q�样的结果，下面是我的分析过�E�，如果有不对的地方请大家指正�?br />��Z��跟踪代码的执行步骤，我设计了一个类X�Q�这个类是对int的模拟，行�ؓ(f��)斚w��与int基本一��_(d��)��除了�?x��)打印出一些帮助我们理解的信息�Q�代码如下：(x��)

class X
{
public:
    X(){cout<<"default construct"<<endl;}
    X(int a):i(a){ cout<<"construct "<<i<<endl;}
    ~X(){ cout<<"desconstruct "<<i<<endl;}
    X(const X& x):i(x.i)
    {
        cout<<"copy construct "<<i<<endl;
    }
    X& operator++()
    {
        cout<<"operator ++(pre) "<<i<<endl;
        ++i;
        return *this;
    }
    const X operator++(int)
    {
        cout<<"operator ++(post) "<<i<<endl;
        X x(*this);
        ++i;
        return x;
    }
    X& operator=(int m)
    {
        cout<<"operator =(int)"<<endl;
        i = m;
        return *this;
    }
    X& operator=(const X& x)
    {
        cout<<"operator =(X)"<<endl;
        i=x.i;
        return *this;
    }
    /////////////////////////
    friend ostream& operator<<(ostream& os,const X& x)
    {
        os<<x.i;
        return os;
    }
    friend X operator+(const X& a,const X& b)
    {
        cout<<"operator +"<<endl;
return X(a.i+b.i);
    }
    //////////////////////////
public:
    int i;
};

然后执行以下代码�Q?br />

X a(10),b(6);
cout<<"sum:" <<a+b<<" a:"<<a++<<" b:"<<b++<<endl;

使用GCC4�?�~�译后，代码的执行结果如下：(x��)

construct 10

construct 6

operator ++(post) 6

copy construct 6

operator ++(post) 10

copy construct 10

operator +

construct 18

sum:18 a:10 b:6

desconstruct 18

desconstruct 10

desconstruct 6

desconstruct 7

desconstruct 11

我们来简单分析下�q�个执行�q�程�Q?/div>

construct 10

construct 6 �Q�／�q�两行输出对应于 X a(10),b(6);

operator ++(post) 6

copy construct 6 �Q�／表明首先执行�?nbsp; cout<<"sum:" < b++�q�个表达式返回了一个��gؓ(f��)6的��(f��)时对象，而b本��n则变成了7�?br />

operator ++(post) 10
copy construct 10 �Q�／�q�句的分析同�?br />

operator +

construct 18 //对应于表辑ּ� a+b ,可以看到�Q�此时的a和b已经变成�?1�?。表辑ּ��q�回了一个��gؓ(f��)18的��(f��)时对象�?br />

sum:18 a:10 b:6 �Q�／输出的结果，从结果可以看出，实际上打印出的值分别�ؓ(f��) a+b,a++和b�Q�＋三个表达式所�q�回的��(f��)时变量�?/div>

desconstruct 18 �Q�／a�Q�b 表达式返回的临时变量的析�?/div>

desconstruct 10 �Q�／a�Q�＋表达式返回的临时变量的析�?/div>

desconstruct 6 �Q�／b�Q�＋表达式返回的临时变量的析�?/div>

desconstruct 7 �Q�／变量a 的析�?/div>

desconstruct 11 �Q�／变量b的析�?br />
真相大白了。�ؓ(f��)什么编译器�?x��)这��h��~�译�q�个表达式呢�Q?br />下面2楼的夜风同学�l�出了正��答案。。�ؓ(f��)了不误导后面的同学，�Ҏ(gu��)��~�辑掉。�?br />
上述实验的环境均为GCC4�? 据同学说VS2010执行的结果在DEBUG下和RELEASE下居然分别�ؓ(f��)�Q?6 10 6 �?8 10 6�Q�不�q�我没有去验证过�Q�有兴趣的同学可以去验证�q�分析一下�?br />做这样一道题�q�是让我收获很多�Q��m��Z��C�Q�＋的基��?br />今天��写道这里，后面有时间会(x��)陆箋攑և�对其�?#8220;陷阱”题目的分析�?br />�Q�未完待�l�）

江浸�?/a> 2011-08-13 17:30 发表评论

Wed, 25 May 2011 17:10:00 GMT

首先�Q�BOOST中有4�U�有关互斥量得概��c�?br />1.LOCKABLE :仅支持排它型所有权
2.TIMEDLOCKABLE�Q�支持带��时的排它型所有权
3.SHAREDLOCKABLE�Q?支持带超时的排他型所有权和共享型所有权�Q�读写锁�Q?br />4.UPGRADELOCKABLE�Q?nbsp;

支持带超时的排他型所有权和共享型所有权�Q�以及共享型所有权升��为排他型所有权�Q�升�U�过�E�阻塞）(也支持降�U?

可以看到2强化�?,3强化�?.4强化�?�Q�支持某一概念则一定支持其强化自的概念�?br />
boost::mutex 实现了LOCKABLE概念 �Q�boost::recursive_mutex 是其递归锁的版本�Q?br />boost::timed_mutex 实现了TIMEDLOCKABLE概念

�Q�boost::recursive_timed_mutex 是其递归锁的版本�Q?br />boost::shared_mutex实现了SHAREDLOCKABLE概念
boost::shared_mutex同样实现了UPGRADELOCKABLE概念

��Z��提供RAII操作风格和安全等其他一些原因BOOST不希望用��L(f��ng)��接调用各�U�MUTEX�c�d��中的相关接口�Q�而是通过它提供的一些LOCK_TYPE来帮助我们调用�?br />
主要的LOCK_TYPE包括�Q?br />
boost::unique_lock 针对支持LOCKABLE概念的类型（上述4中MUTEX�c�d��都支持LOCKABLE概念�Q�。以RAII的方式调用该�cȝ��lock()

�Q�调用成功后排它的独占该互斥量）�?unlock() �Ҏ(gu��)��?br />
boost::shared_lock针对支持SHAREDLOCKABLE概念的类型，boost::shared_mutex实现了该概念�Q�注意，支持SHAREDLOCKABLE概念的类既支持排他的独占�Q�写锁，通过调用lock unlock�p�d��函数�Q�，也支持共享的方式占用�Q�读锁，通过调用lock_shared�p�d��Q�，

shared_lock默认调用

lock_shared�p�d��?br />
最主要最常用的就是上面这两个LOCK�c�d��Q�分别代表独占方式和�׃�n方式�Q�其他的��׃��一一分析了�?br />
下面是个�?a >http://hi.baidu.com/jrckkyy/blog/item/d7ccb508dfba2e3ce8248817.html此处扑ֈ�的例�?br />

typedef boost::shared_mutex rwmutex;
typedef boost::shared_lock readLock;
typedef boost::uniq_lock writeLock;

rwmutex _rwmutex;

void readOnly()
{
...
{ // 临界�?nbsp;
readLock rdlock

(_rwmutex);
...
do something
...
}
...
}

void writeOnly()
{
...
{ // 临界�?nbsp;
writeLock wlock(

_rwmutex);
...
do something
...
}
...
}

江浸�?/a> 2011-05-26 01:10 发表评论