A(长)以前我写了一个网络蜘蛛，我多线程，以使并发请求同时发生。这是在我的Python青年，在我知道
GIL和它为多线程代码(IE，大多数时间的东西最终序列化之前创建的相关联的困难的日子之前的日子…)
我想重新编写这段代码，使其更强大，性能更好。基本上有两种方法可以做到这一点：我可以在2.6中使用新的multiprocessing module，或者我可以去某种反应器/基于事件的模型。我宁愿做后，因为它更简单，更不容易出错。
所以问题涉及什么框架将最适合我的需要。以下是我知道的选项到目前为止的列表：
> Twisted：Python反应器框架的granddaddy：似乎复杂，有点。肿。陡峭的学习曲线为一个小任务。
> Eventlet：从lindenlab的家伙。基于Greenlet的框架，面向这些类型的任务。我看看代码虽然，它不是太漂亮：非pep8兼容，分散与打印(为什么人们做这个框架！)，API似乎有点不一致。
> PyEv：不成熟，似乎没有人现在使用它，虽然它是基于libevent所以它有一个坚实的后端。
> asyncore：从stdlib：über低级，似乎很多legwork涉及只是为了让事情离开地面。
> tornado：虽然这是一个面向服务器的产品，旨在服务器动态网站，它的功能有一个async HTTP client和一个简单的ioloop.看起来它可以完成工作，但不是它的目的。
[编辑：不在Windows上运行不幸的是，它计数了我 – 它的要求我支持这个跛脚平台]
有什么我错过了吗？当然必须有一个图书馆，适合简化的异步网络库的甜点！
[编辑：大感谢intgr他的指针this page.如果你滚动到底部，你会看到一个非常好的项目列表，旨在解决这种任务的方式或另一种。实际上，自从Twisted诞生以来，事情确实发生了变化：人们现在似乎倾向于基于co-routine的解决方案，而不是传统的反应器/回调方案。这种方法的好处是更清晰更直接的代码：我确定发现在过去，特别是在使用boost.asio在C，基于回调的代码可以导致设计，可能是难以遵循，并相对不明确的未经训练眼。使用协同例程允许你编写看起来更加同步的代码。我想现在我的任务是找出这些许多图书馆中的哪一个我喜欢的外观，并给它一个去！很高兴我问现在…]
[编辑：可能感兴趣的任何人谁跟随或绊住这个问题或关心这个话题在任何意义：我发现一个真正伟大的写的目前的状态the available tools这项工作]

1.基础概念
互斥量： 就是最基本的锁，利用上锁和开锁使多个线程在竞争区域串行化。是最基础的同步量，条件变量必须和一个互斥量相关联，而暂时所接触到的作为线程同步量使用的信号量，一般也是和互斥量共同使用的。拒我暂时的理解，其他两个同步量可以说是，一种对于互斥量的扩展。

条件变量： 编程中经常会遇到这样的情景，角色A接下来步骤的进行，需要依赖于某个状态a，而状态a由角色B去改变。如果在串行中的话，这个角色大致就相当于函数，例如A need f(a)，a need B。转换到并行的语境，A和B不再是串行执行的“步骤”，而是两个并行执行的线程，因此线程A和线程B就需要同步。这个情景使用互斥量是可以实现的，但是从CPU利用、响应速度各方面来说，单纯用互斥量来实现的方案都不怎么好。因此，就推出了条件变量这个同步量，专门解决这个情景。

信号量： 据我现在粗浅的接触，信号量又是一个相对来说，比条件变量解决的问题域要更窄一点的同步量。暂时所知，主要就是解决生产者-消费者问题，还有限流问题这些有关于控制线程数量的问题。sem_init(sem, 0, val)中的val需要区分一下，这是信号量的初始值，而存在一个信号量的最大值，这个信号量的最大值和允许“工作”的线程的最大值是完全不同的概念。former只不过是linux系统中限制的，信号量可设置的最大值。而later我认为，就是取决于信号量的初值，假设一开始为5，5个“工作”线程被允许“工作”，然后信号量减为0，其他“工作”线程就被阻塞了。那么被阻塞的“工作”线程，什么时候才能开始“工作”呢？只有等“工作”中的线程“工作”完了，然后调用sem_post()将信号量增加回去才行。如果一直这样正常“工作”，那么后续的过程都会是这样出出入入的，而正在“工作”的线程将会保持在5，也就是信号量的初值。
待续。。。

1. 信号量概述
System V信号量又被称为System V信号量集，信号量的作用和消息队列不太一样，消息队列的作用是进程之间传递消息。而信号量的作用是为了同步多个进程的操作。
一般来说，信号量和某种预先定义的资源相关联的。信号量元素的值，表示与之关联的资源个数。内核会负责维护信号量的值，并确保其值不小于0。
使用最广泛的信号量是二值信号量。对于这种信号量而言，它只有两种合法值：0和1，对应一个可用的资源。若当前有资源可用，则与之对应的二值信号量的值为1；若资源已经被占用，则与之对应的二值信号量的值为0.当前进程申请资源时，如果当前信号量的值为0，那么进程会陷入阻塞，直到有其他进程释放资源，将信号量的值加1才能被唤醒。
从这个角度看，二值信号量和互斥量所起的作用非常类似。那信号量和互斥量有何不同之处呢？
互斥量是用来保护临界区的，所谓临界区，是指同一时间只能容忍一个进程的进入。而信号量是用来管理资源的，资源的个数不一定是1，可能同时存在多个一模一样的资源，因此容忍多个进程同时使用资源。
更重要的区别是，互斥量和信号量解决的问题是不同的，互斥量的关键在于互斥、排他，同一时间只允许一个线程访问临界区。这种严格的互斥，决定了解铃还须系铃人，即加锁进程必然也是解锁进程
而信号量的关键在于资源的多少和有无。申请资源的进程不一定要释放资源，信号量同样可以用于生产者-消费者的场景。在这种场景下，生产者进程只负责增加信号量的值，而消费者进程只负责减少信号的值。彼此之间通过信号的值来同步。
和二值信号量相比，System V信号量在两个维度上都做了扩展。
第一，资源的数目可以是多个。资源个数超过一个的信号量称为计数信号量
第二，允许同时管理多种资源，由多个计数信号量组成的一个集合称为计数信号量集，每个技术信号量管理一种资源。比如第一种资源的总数是5，第二种资源的总数是10.在使用过程中可选择申请那种资源或哪几种资源。
2. 创建或打开信号量
创建或打开信号量的函数为semget，其接口定义如下：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

第二个参数nsems表示信号量集中信号量的个数。换句话说，就是要控制几种资源。大部分情况下只控制一种。如果并非创建信号量，仅仅是访问已经存在的信号量集，可以将nsem指定为0.
semflg支持多种标志位。目前支持IPC_CREAT和IPC_EXCL标志位，其含义不在阐述。
在创建信号量时，需要考虑的问题是系统限制
3. 操作信号量
semop函数负责修改集合中一个或多个信号量的值，其定义如下：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);

函数的第一个参数是通过semget获取到的信号量的标识符，第二个参数是sembuf类型的指针。sembuf结构体定义在sys/sem.h头文件中。一般来说，该结构体至少包含以下三个成员变量：
struct sembuf {
unsigned short int sem_num ;
short sem_op ;
short sem_flg;
}

成员变量sem_num解决的是操作那个信号量的问题。因为信号量集中可能存在多个信号量，需要用这个参数来告知semop函数操作的是哪个信号量，0表示第一个信号量，1表示第二个信号量，以此类推，最大为nsems-1，即不得超过集合中信号量的个数。如果sem_num的值小于0，或者大于等于集合中信号量的个数，semop调用会返回失败，并置errno为EFBIG。
semop函数的典型用法如下所示：
struct sembuf myopsbuf[3] ；
myopsbuf[0].sem_num = 0; /*操作信号量集中的第0个信号量*/
myopsbuf[0].sem_op = -1; /*信号量0的值减去1，即申请1个资源*/
myopsbuf[0].sem_flg = 0 ;
myopsbuf[1].sem_num = 1; /*操作信号量集中的第1个信号量*/
myopsbuf[1].sem_op = 2 ; /*信号量1的值加上2*/
myopsbuf[1].sem_flg = 0;
myopsbuf[2].sem_num = 2; /*操作信号量集中的第2个信号量*/
myopsbuf[2].sem_op = 0; /*等待第2个信号量的值变为0*/
myopsbuf[2].sem_flg = 0;
if(semop(semid,myopsbuf,3) == -1)
{
/*error handler here*/
}

semop函数每次会操作一组信号量，每个信号量由一个sembuf来表示，修改一个信号量最好也将其定义成struct sembuf ops[1]这样的数组，semop函数的第三个参数表示要操作的信号量的个数。

信号量的定义：

它使用一个整型变量来累计唤醒次数，供以后使用。

原子操作：

是指一组相关联的操作要么都不间断地执行，要么都不执行。

 

下面有两种操作：down 和 up ，对一信号量执行down操作，则是检查其值是否大于0。若该值大于0，则将其值减1并继续，若该值为0，则进程将睡眠，而且此时down操作并未结束。(在检查数值，修改变量值以及可能发生的睡眠操作均作为一个单一的，不可分割的原子操作完成)，保证一旦一个信号量操作开始，则在该操作完成或阻塞之前，其他进程均不允许访问该信号量。

刚开始看这段话有点懵，然后看了别人的回答；我觉得还挺好理解的：

(灵剑/知乎)：

信号量就是在一个叫做互斥区的门口放一个盒子，盒子里面装着固定数量的小球，每个线程过来的时候，都从盒子里面摸走一个小球，然后去互斥区里面浪（？），浪开心了出来的时候，再把小球放回盒子里。如果一个线程走过来一摸盒子，得，一个球都没了，不拿球不让进啊，那就只能站在门口等一个线程出来放回来一个球，再进去。这样由于小球的数量是固定的，那么互斥区里面的最大线程数量就是固定的，不会出现一下进去太多线程把互斥区给挤爆了的情况。这是用信号量做并发量限制。

另外一些情况下，小球是一次性的，线程拿走一个进了门，就把小球扔掉了，这样用着用着小球就没了，不过有另外一些线程（一般叫做生产者）会时不时过来往盒子里再放几个球，这样就可以有新的线程（一般叫做消费者）进去了，放一个球进一个线程，这是信号量做同步功能。你截图里的例子就是这个情况，主线程是生产者，通过sem_post往盒子里放小球（信号量加一），而其他线程是消费者，通过sem_wait从盒子里拿小球（信号量减一），如果遇到盒子里一个小球都没有（信号量为0），就会开始等待信号量不为0，然后拿走一个小球（信号量减一）再继续。

本质上来说信号量就是那个盒子，以及“摸不到球就不让进”这个机制。

上面的这个例子很形象，以下子就理解了；这个就像是取麻辣烫的牌子，一共只有这么多，有牌子才给吃，

 

关于 保证一旦一个信号量操作开始，则在该操作完成或阻塞之前，其他进程均不允许访问该信号量

是不是相当于一个组正在使用中，另一个组(另一个进程)不能直接插入;

用信号量来解决生产者-消费者问题(互斥)

#define N 100        /* 缓冲区中槽的数目*/
typedef int semaphore;    /*信号量是一种特殊的整型数据*/
semaphore mutex = 1;   /*控制对临界区的访问*/
//此时的信号量 mutex 保持的对于临界区的访问控制，即保证了任一时刻只有一个进程读写缓存区的相关变量
semaphore empty= N;    /*计数缓存区的空槽数目*/
semaphore full =0;    /*计数缓冲区的满槽数目*/

void producer(void)
{    
     int item;
        while(true)
    { item=produce_item();    //产生放在缓存区中的数据
      down(&empty);    //拿到一个槽
      down(&mutex)     //进入缓冲区
      insert_item(item);    //放数据
      up(&mutex);        //离开临界区
      up(&full);        //将满槽的数目加1
    }
}

void consumer(void)
{    
     int item;
        while(true)
    { item=produce_item();    //产生放在缓存区中的数据
      down(&full);    //拿到一个有数据的槽，并将有数据的槽减1
      down(&mutex)     //进入缓冲区
      item=remove_item();    //放数据
      up(&mutex);        //离开临界区
      up(&empty);        //将空槽的数目加1
      consumer_item(item);    //处理数据
    }
}

上面这段code控制着临界区只能有一个进程进入，从而实现了互斥；

信号量的另一种用途就是实现同步，信号量full 和 empty 用来保证某种事件的顺序发生或不发生。在本例中，它们保证当缓冲区满的时候生产者停止运行，以及当缓冲区空的时候消费者停止运行。所以这和互斥是不同的。

下面介绍pthread中的互斥量；

其基本机制是使用一个可以被锁定和解锁的互斥量来保护每个临界区。一个线程如果想要进入临界区，它首先尝试锁住相关的互斥量。如果互斥量没有加锁，那么这个可以立即进入，并且该互斥量被自动锁定以防止其他线程进入。如果互斥量已经被加锁，则调用线程被阻塞，直到该互斥量被解锁。

在生产者和消费者的例子中，还用到了条件变量，用来实现同步；

条件变量：它允许线程由于一些未达到的条件而阻塞。

一个线程将产品放在一个缓冲区内，由另一个线程将他们取出。如果生产者发现缓冲区中没有空槽可以使用了，它不得不阻塞起来直到有一个空槽可以使用。生产者使用互斥量可以进行原子性检查，(因为临界区已经被阻塞，不允许其他线程进入，所以不会被打断)，而不受其他线程干扰。但是当缓冲区已经满了以后，生产者需要一种方法来阻塞自己并在以后被唤醒。这便是条件变量做的事了。

#include <stdio.h>
#include <pthread.h>
#define MAX 10			
pthread_mutex_t mutex;
pthread_cond_t condc,condp;
int buffer=5;		//最多生产多少个

//生产者
void *producer(void *ptr)
{
	int i;
	for(i=1;i<=MAX;++i)
    {   
    	pthread_mutex_lock(&mutex);
		while(buffer==5){
		//这里的等待表示，此时锁被释放，而此线程被阻塞，直到达到某个条件，因为锁被释放，
	    //因此其他就绪好的线程就可以被CPU调用，于是消费者开始运行
			pthread_cond_wait(&condp,&mutex);
		}
		printf("生产一个\n");
		buffer++;
		printf("还有多少存货  %d\n", buffer);
		//因为此时生产者有生产东西出来，从而消费者就可以使用了，
	  	//因此在这里就唤醒消费者，让消费者线程变成就绪状态(如果之前被阻塞的话)
		pthread_cond_signal(&condc);
		pthread_mutex_unlock(&mutex);
    }

	pthread_exit(0);
}


//消费者
void *consumer(void *ptr)
{
	int i;
	for(i=1;i<=MAX;++i)
    {   
    	pthread_mutex_lock(&mutex);
		while(buffer==0){
			pthread_cond_wait(&condc,&mutex);
		}
		printf("消费了一个\n");
		buffer--;
		printf("剩余  %d个\n", buffer);
		pthread_cond_signal(&condp);
		pthread_mutex_unlock(&mutex);
    }

	pthread_exit(0);
}

int main(int argc,char *argv[])
{
	pthread_t pro,con;
	pthread_mutex_init(&mutex,0);
	pthread_cond_init(&condc,0);
	pthread_cond_init(&condp,0);
	pthread_create(&con,0,consumer,0);
	pthread_create(&pro,0,producer,0);
	pthread_join(pro,0);
	pthread_join(con,0);
	pthread_cond_destroy(&condc);
	pthread_cond_destroy(&condp);
	pthread_mutex_destroy(&mutex);
	return 0;
}
















明显下面输出是同步的，并且保证了生产一个，就消费一个

/*得到输出结果为*/
生产一个  1
消费一个  1
生产一个  2
消费一个  2
生产一个  3
消费一个  3
生产一个  4
消费一个  4
生产一个  5
消费一个  5
生产一个  6
消费一个  6
生产一个  7
消费一个  7
生产一个  8
消费一个  8
生产一个  9
消费一个  9
生产一个  10
消费一个  10