对于网络并发编程而言，多线程与多进程算是最常见的需求场景了。毕竟网站开放就是想要更多的流量访问的。
回顾
回顾下之前学过的关于线程，进程和协程的知识点
IO密集型任务--用多线程更好
计算密集型任务--用多进程更好
线程概念：计算机中工作的最小单元
进程：默认有主线程，可以有多线程共存，并共享内存资源。
协程：使用进程中的一个线程去做多个任务，微线程pypy
GIL:全局解释器锁，python特有，用于在进程中对所有线程加锁，保证同时只能有一个线程被CPU调度
一句话说明什么是协程：协程是一种用户态的轻量级线程。
协程的特点：协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。
那么符合什么条件我们可以称之为协程？
协程需要满足四个条件：
- 必须在只有一个单线程里实现并发
- 修改共享数据不需加锁
- 用户程序里自己保存多个控制流的上下文栈
- 一个协程遇到IO操作自动切换到其它协程
当然，协程也有自身的优缺点，这里不展开。
在python中，我们可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
论事件驱动与异步
异步IO
Python中的select模块专注于I/O多路复用，提供了select poll epoll三个方法(其中后两个在Linux中可用，windows仅支持select)，另外也提供了kqueue方法(freeBSD系统)
select模块
select的优点在于，跨平台支持良好。问题在于，select问题在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024；且select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。
poll模块
poll和select本质上没有区别，区别在于没有最大文件描述符数量的限制。它的缺是点包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。
epoll
epoll可同时支持水平触发和边缘触发，理论上边缘触发实现性能更高，但代码实现复杂。
epoll相对于select的改进有两点：
1.epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，这里使用了内存映射的技术，节省了文件描述符在系统调用时复制的开销。
2.另一个本质的改进在于epoll采用基于事件的就绪通知方式。epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
进程切换的概念
为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。因此可以说，任何进程都是在操作系统内核的支持下运行的，是与内核紧密相关的。
但进程切换十分消耗OS资源。对于进程流，会在请求系统未响应或是等待某种操作完成时，系统自动执行阻塞原语，使自己由运行状态转变为阻塞状态。
进程的阻塞是进程自身的一种主动行为，也因此只有处于运行态的进程（获得CPU），才可能将其转为阻塞状态。当进程进入阻塞状态，是不占用CPU资源的。
了解水平触发和边缘触发：
Level_triggered(水平触发，有时也称条件触发)：当被监控的文件描述符上有可读写事件发生时，epoll.poll()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll.poll()时，它还会通知你在上没读写完的文件描述符上继续读写，当然如果你一直不去读写，它会一直通知你！！！如果系统中有大量你不需要读写的就绪文件描述符，而它们每次都会返回，这样会大大降低处理程序检索自己关心的就绪文件描述符的效率！！！ 优点很明显：稳定可靠
Edge_triggered(边缘触发，有时也称状态触发)：当被监控的文件描述符上有可读写事件发生时，epoll.poll()会通知处理程序去读写。如果这次没有把数据全部读写完(如读写缓冲区太小)，那么下次调用epoll.poll()时，它不会通知你，也就是它只会通知你一次，直到该文件描述符上出现第二次可读写事件才会通知你！！！这种模式比水平触发效率高，系统不会充斥大量你不关心的就绪文件描述符！！！缺点：某些条件下不可靠
epoll事件：
EPOLLIN Available for read 可读 状态符为1 EPOLLOUT Available for write 可写 状态符为4 EPOLLPRI Urgent data for read EPOLLERR Error condition happened on the assoc. fd 发生错误 状态符为8 EPOLLHUP Hang up happened on the assoc. fd 挂起状态 EPOLLET Set Edge Trigger behavior, the default is Level Trigger behavior 默认为水平触发，设置该事件后则边缘触发 EPOLLONESHOT Set one-shot behavior. After one event is pulled out, the fd is internally disabled EPOLLRDNORM Equivalent to EPOLLIN EPOLLRDBAND Priority data band can be read. EPOLLWRNORM Equivalent to EPOLLOUT EPOLLWRBAND Priority data may be written. EPOLLMSG Ignored.
Python select
python中的select方法直接调用系统的IO接口，它监控特定的文件句柄何时变成readable和writeable，或通信错误，select()使得监控多个连接变得简单。
RabbitMQ
rabbitMQ是消息队列；想想之前的我们学过队列queue：threading queue（线程queue，多个线程之间进行数据交互）、进程queue（父进程与子进程进行交互或者同属于同一父进程下的多个子进程进行交互）；如果两个独立的程序，那么之间是不能通过queue进行交互的,这时候我们就需要一个中间代理即rabbitMQ。一般用于Linux服务器
消息队列：
- RabbitMQ
- ZeroMQ
- ActiveMQ
- .......
工作原理：
安装和使用
python安装rabbitMQ模块
pip install pika or easy_install pika or 源码 https://pypi.python.org/pypi/pika
实例：最简单的通信队列实现
发送端
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel() #声明一个管道(管道内发消息)
channel.queue_declare(queue='lzl') #声明queue队列
channel.basic_publish(exchange='',
routing_key='lzl', #routing_key 就是queue名
body='Hello World!'
)
print("Sent 'Hello,World!'")
connection.close() #关闭
接收端
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='lzl')
def callback(ch,method,properties,body):
print(ch,method,properties)
#ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> 管道内存对象地址
#methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息
# 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=lzl'])>
#properties:<BasicProperties>
print("Received %r"%body)
channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="lzl",
no_ack=True) #接受到消息后不返回ack，无论本地是否处理完消息都会在队列中消失
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始收消息
注：windows连linux上的rabbitMQ会出现报错，需要提供用户名密码
3、RabbitMQ消息分发轮询
先启动消息生产者，然后再分别启动3个消费者，通过生产者多发送几条消息，你会发现，这几条消息会被依次分配到各个消费者身上
在这种模式下，RabbitMQ会默认把p发的消息公平的依次分发给各个消费者(c),跟负载均衡差不多
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() #声明一个管道(管道内发消息) channel.queue_declare(queue='lzl') #声明queue队列 channel.basic_publish(exchange='', routing_key='lzl', #routing_key 就是queue名 body='Hello World!' ) print("Sent 'Hello,World!'") connection.close() #关闭
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='lzl') def callback(ch,method,properties,body): print(ch,method,properties) #ch:<pika.adapters.blocking_connection.BlockingChannel object at 0x002E6C90> 管道内存对象地址 #methon:<Basic.Deliver(['consumer_tag=ctag1.03d155a851b146f19cee393ff1a7ae38', #具体信息 # 'delivery_tag=1', 'exchange=', 'redelivered=False', 'routing_key=lzl'])> #properties:<BasicProperties> print("Received %r"%body) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息 queue="lzl", no_ack=True) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming() #开始收消息
通过执行pubulish.py和consume.py可以实现上面的消息公平分发，那假如c1收到消息之后宕机了，会出现什么情况呢？rabbitMQ是如何处理的？现在我们模拟一下
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() #声明一个管道(管道内发消息) channel.queue_declare(queue='lzl') #声明queue队列 channel.basic_publish(exchange='', routing_key='lzl', #routing_key 就是queue名 body='Hello World!' ) print("Sent 'Hello,World!'") connection.close() #关闭
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika,time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='lzl') def callback(ch,method,properties,body): print("->>",ch,method,properties) time.sleep(15) # 模拟处理时间 print("Received %r"%body) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息 queue="lzl", no_ack=True) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming() #开始收消息
在consume.py的callback函数里增加了time.sleep模拟函数处理，通过上面程序进行模拟发现，c1接收到消息后没有处理完突然宕机，消息就从队列上消失了，rabbitMQ把消息删除掉了；如果程序要求消息必须要处理完才能从队列里删除，那我们就需要对程序进行处理一下
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() #声明一个管道(管道内发消息) channel.queue_declare(queue='lzl') #声明queue队列 channel.basic_publish(exchange='', routing_key='lzl', #routing_key 就是queue名 body='Hello World!' ) print("Sent 'Hello,World!'") connection.close() #关闭
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika,time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='lzl') def callback(ch,method,properties,body): print("->>",ch,method,properties) #time.sleep(15) # 模拟处理时间 print("Received %r"%body) ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息 queue="lzl", ) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming() #开始收消息
通过把consume.py接收端里的no_ack=True去掉之后并在callback函数里面添加ch.basic_ack(delivery_tag = method.delivery_tag，就可以实现消息不被处理完不能在队列里清除
查看消息队列数：
4、消息持久化
如果消息在传输过程中rabbitMQ服务器宕机了，会发现之前的消息队列就不存在了，这时我们就要用到消息持久化，消息持久化会让队列不随着服务器宕机而消失，会永久的保存下去
发送端：
# -*- coding:utf-8 -*-
#-Author-Lian
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel() #声明一个管道(管道内发消息)
channel.queue_declare(queue='lzl',durable=True) #队列持久化
channel.basic_publish(exchange='',
routing_key='lzl', #routing_key 就是queue名
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode = 2 #消息持久化
)
)
print("Sent 'Hello,World!'")
connection.close() #关闭
接收端：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
import pika,time
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='lzl',durable=True)
def callback(ch,method,properties,body):
print("->>",ch,method,properties)
time.sleep(15) # 模拟处理时间
print("Received %r"%body)
ch.basic_ack(delivery_tag=method.delivery_tag)
channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息
queue="lzl",
)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() #开始收消息
5、消息公平分发
如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置perfetch=1,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了
channel.basic_qos(prefetch_count=1)
带消息持久化+公平分发
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() #声明一个管道(管道内发消息) channel.queue_declare(queue='lzl',durable=True) #队列持久化 channel.basic_publish(exchange='', routing_key='lzl', #routing_key 就是queue名 body='Hello World!', properties=pika.BasicProperties( delivery_mode = 2 #消息持久化 ) ) print("Sent 'Hello,World!'") connection.close() #关闭
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika,time connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='lzl',durable=True) def callback(ch,method,properties,body): print("->>",ch,method,properties) time.sleep(15) # 模拟处理时间 print("Received %r"%body) ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_qos(prefetch_count=1) channel.basic_consume(callback, #如果收到消息，就调用callback函数处理消息 queue="lzl", ) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming() #开始收消息
6、PublishSubscribe(消息发布订阅)
之前的例子都基本都是1对1的消息发送和接收，即消息只能发送到指定的queue里，但有些时候你想让你的消息被所有的Queue收到，类似广播的效果，这时候就要用到exchange了，
An exchange is a very simple thing. On one side it receives messages from producers and the other side it pushes them to queues. The exchange must know exactly what to do with a message it receives. Should it be appended to a particular queue? Should it be appended to many queues? Or should it get discarded. The rules for that are defined by the exchange type.
Exchange在定义的时候是有类型的，以决定到底是哪些Queue符合条件，可以接收消息
fanout: 所有bind到此exchange的queue都可以接收消息
direct: 通过routingKey和exchange决定的那个唯一的queue可以接收消息
topic:所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息
headers: 通过headers 来决定把消息发给哪些queue
表达式符号说明：#代表一个或多个字符，*代表任何字符
例：#.a会匹配a.a，aa.a，aaa.a等
*.a会匹配a.a，b.a，c.a等
注：使用RoutingKey为#，Exchange Type为topic的时候相当于使用fanout
① fanout接收所有广播：广播表示当前消息是实时的，如果没有一个消费者在接受消息，消息就会丢弃，在这里消费者的no_ack已经无用，因为fanout不会管你处理消息结束没有，发过的消息不会重发，记住广播是实时的
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='logs', type='fanout') message = "info: Hello World!" channel.basic_publish(exchange='logs', routing_key='', #广播不用声明queue body=message) print(" [x] Sent %r" % message) connection.close()
#!/usr/bin/env python # -*- coding:utf-8 -*- #-Author-Lian import pika connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='logs', type='fanout') result = channel.queue_declare(exclusive=True) # 不指定queue名字,rabbit会随机分配一个名字, # exclusive=True会在使用此queue的消费者断开后,自动将queue删除 queue_name = result.method.queue channel.queue_bind(exchange='logs', # 绑定转发器，收转发器上面的数据 queue=queue_name) print(' [*] Waiting for logs. To exit press CTRL+C') def callback(ch, method, properties, body): print(" [x] %r" % body) channel.basic_consume(callback, queue=queue_name, no_ack=True) channel.start_consuming()
② 有选择的接收消息 direct: 同fanout一样，no_ack在此要设置为True，不然队列里数据不会清空（虽然也不会重发）
RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据 关键字 判定应该将数据发送至指定队列
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='direct_logs', type='direct') severity = sys.argv[1] if len(sys.argv) > 1 else 'info' message = ' '.join(sys.argv[2:]) or 'Hello World!' channel.basic_publish(exchange='direct_logs', routing_key=severity, body=message) print(" [x] Sent %r:%r" % (severity, message)) connection.close()
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='direct_logs', type='direct') result = channel.queue_declare(exclusive=True) queue_name = result.method.queue severities = sys.argv[1:] if not severities: sys.stderr.write("Usage: %s [info] [warning] [error] " % sys.argv[0]) sys.exit(1) for severity in severities: channel.queue_bind(exchange='direct_logs', queue=queue_name, routing_key=severity) print(' [*] Waiting for logs. To exit press CTRL+C') def callback(ch, method, properties, body): print(" [x] %r:%r" % (method.routing_key, body)) channel.basic_consume(callback, queue=queue_name, no_ack=True) channel.start_consuming()
③ 更细致的消息过滤 topic:
Although using the direct exchange improved our system, it still has limitations - it can't do routing based on multiple criteria.
In our logging system we might want to subscribe to not only logs based on severity, but also based on the source which emitted the log. You might know this concept from the syslog unix tool, which routes logs based on both severity (info/warn/crit...) and facility (auth/cron/kern...).
That would give us a lot of flexibility - we may want to listen to just critical errors coming from 'cron' but also all logs from 'kern'
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='topic_logs', type='topic') routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info' message = ' '.join(sys.argv[2:]) or 'Hello World!' channel.basic_publish(exchange='topic_logs', routing_key=routing_key, body=message) print(" [x] Sent %r:%r" % (routing_key, message)) connection.close()
import pika import sys connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='topic_logs', type='topic') result = channel.queue_declare(exclusive=True) queue_name = result.method.queue binding_keys = sys.argv[1:] if not binding_keys: sys.stderr.write("Usage: %s [binding_key]... " % sys.argv[0]) sys.exit(1) for binding_key in binding_keys: channel.queue_bind(exchange='topic_logs', queue=queue_name, routing_key=binding_key) print(' [*] Waiting for logs. To exit press CTRL+C') def callback(ch, method, properties, body): print(" [x] %r:%r" % (method.routing_key, body)) channel.basic_consume(callback, queue=queue_name, no_ack=True) channel.start_consuming()
RPC（Remote procedure call ）双向通信
To illustrate how an RPC service could be used we're going to create a simple client class. It's going to expose a method named call which sends an RPC request and blocks until the answer is received:
rpc client：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
import pika
import uuid,time
class FibonacciRpcClient(object):
def __init__(self):
self.connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
self.channel = self.connection.channel()
result = self.channel.queue_declare(exclusive=True)
self.callback_queue = result.method.queue
self.channel.basic_consume(self.on_response, #只要收到消息就执行on_response
no_ack=True, #不用ack确认
queue=self.callback_queue)
def on_response(self, ch, method, props, body):
if self.corr_id == props.correlation_id: #验证码核对
self.response = body
def call(self, n):
self.response = None
self.corr_id = str(uuid.uuid4())
print(self.corr_id)
self.channel.basic_publish(exchange='',
routing_key='rpc_queue',
properties=pika.BasicProperties(
reply_to=self.callback_queue, #发送返回信息的队列name
correlation_id=self.corr_id, #发送uuid 相当于验证码
),
body=str(n))
while self.response is None:
self.connection.process_data_events() #非阻塞版的start_consuming
print("no messages")
time.sleep(0.5) #测试
return int(self.response)
fibonacci_rpc = FibonacciRpcClient() #实例化
print(" [x] Requesting fib(30)")
response = fibonacci_rpc.call(30) #执行call方法
print(" [.] Got %r" % response)
rpc server：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#-Author-Lian
import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='rpc_queue')
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n - 1) + fib(n - 2)
def on_request(ch, method, props, body):
n = int(body)
print(" [.] fib(%s)" % n)
response = fib(n)
ch.basic_publish(exchange='',
routing_key=props.reply_to, #回信息队列名
properties=pika.BasicProperties(correlation_id=
props.correlation_id),
body=str(response))
ch.basic_ack(delivery_tag=method.delivery_tag)
#channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request,
queue='rpc_queue')
print(" [x] Awaiting RPC requests")
channel.start_consuming()