python之day12(线程池,redis,rabbitMQ)

参考博客：

mysql
http://www.cnblogs.com/wupeiqi/articles/5699254.html   

缓存
http://www.cnblogs.com/wupeiqi/articles/5132791.html

线程池
http://www.cnblogs.com/wupeiqi/articles/4839959.html

一，线程池：

　　上下文管理

import contextlib

@contextlib.contextmanager
def worker_state(state_list, worker_thread):
    state_list.append(worker_thread)
    try:
        print(state_list)
        yield                       #相当于return 返回值功能，但是不终止整个函数，只是跳出后重新执行函数
    finally:
        state_list.remove(worker_thread)

free_list = []
current_thread = "alex"

with worker_state(free_list, current_thread):
    print(123)        

　　yield简单用法：

def fab(max):
    a,b = 0,1
    while a < max:
        yield a                    #a的值返回给i
        a, b = b, a+b           #然后a被重新赋值

for i in fab(15):
    print(i,',',)    

 　　

　　终止线程池操作

　　---利用contextlib模块以及with完成socket的自动关闭

import contextlib
import socket

@contextlib.contextmanager
def context_socket(host, port):
    s = socket.socket()
    s.bind( (host, port) )   #元组格式
    s.listen(5)
    try:
        yield                   #返回值为None ==sock
    finally:
        s.close()

with context_socket("127.0.0.1", 8888) as sock:
    print(sock)

二 redis 发布订阅
    连接池

import redis

pool = redis.ConnectionPool(host='192.168.61.131', port=6379)       #连接服务器端
r = redis.Redis(connection_pool=pool)       #使用线程池
r.set('foo', 'bar')
print(r.get('foo'))

    自定列表操作
    事务：
        原子性操作
    **发布订阅

import redis

class RedisHelper:
    def __init__(self):
        self.__conn = redis.Redis(host="192.168.61.131")     #redis 服务器

    def public(self, msg, chan):
        self.__conn.publish(chan, msg)          #发布者 发布频道和信息

    def subscribe(self, chan):
        pub = self.__conn.pubsub()               #订阅者接收
        pub.subscribe(chan)                         #接收的频道
        pub.parse_response()                       #接收消息
        return pub        


#等待发布者以及订阅者调用的模块

import demo

obj = demo.RedisHelper()
obj.public('alex db', 'fm111.7')

import demo

obj = demo.RedisHelper()
data = obj.subscribe('fm111.7')
print(data.parse_response())      
#[b'message', b'fm111.7', b'alex db']

　　先执行订阅者完成订阅，然后发布者发布消息，订阅者会接收到发布者发布的消息。

三 rabbitMQ
    1，基础

　　安装方法（参考）：http://yidao620c.iteye.com/blog/1947335

　　基于Queue实现生产者消费者模型：

　　

import queue
import threading
import time

q = queue.Queue(20)
def productor(arg):
    '''
    生产者
    :param arg:
    :return:
    '''
    while True:
        q.put(str(arg) + "-包子")
        time.sleep(1)

def consumer(arg):
    while True:
        print(arg , q.get())
        time.sleep(1)

for i in range(3):
    t = threading.Thread(target = productor, args = (i, ))
    t.start()

for j in range(20):
    t = threading.Thread(target = consumer, args = (j, ))
    t.start()

对于RabbitMQ来说，生产和消费不再针对内存里的一个Queue对象，而是某台服务器上的RabbitMQ Server实现的消息队列。

import pika

#消费者

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.queue_declare(queue='hello34')
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(callback,
                      queue='hello34',
                      no_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

import pika

#生产者

connection= pika.BlockingConnection(pika.ConnectionParameters(
    host='192.168.61.131'
))

channel = connection.channel()

channel.queue_declare(queue='hello34')

channel.basic_publish(exchange='',
                      routing_key='hello34',
                      body='hello world')
print(" [x] Sent 'Hello World!'")
connection.close()

1、acknowledgment 消息不丢失

no-ack ＝ False，如果消费者遇到情况(its channel is closed, connection is closed, or TCP connection is lost)挂掉了，那么，RabbitMQ会重新将该任务添加到队列中。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    import time
    time.sleep(10)
    print('ok')
    ch.basic_ack(delivery_tag = method.delivery_tag)    #回复队列确认任务已完成

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

2、durable   消息不丢失（持久化）

channel.queue_declare(queue='hello1', durable=True) 在消费者和生产者都需要设置
通过delivery_mode = 2, 实现消息持久化

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.61.131'))
channel = connection.channel()

# make message persistent
channel.queue_declare(queue='hello1', durable=True)


def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    import time
    time.sleep(10)
    print('ok')
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,
                      queue='hello1',
                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

#消费者

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.61.131'))
channel = connection.channel()

# make message persistent
channel.queue_declare(queue='hello1', durable=True)

channel.basic_publish(exchange='',
                      routing_key='hello1',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2, # make message persistent
                      ))
print(" [x] Sent 'Hello World!'")
connection.close()

#生产者

3、消息获取顺序

默认消息队列里的数据是按照顺序被消费者拿走，例如：消费者1 去队列中获取 奇数 序列的任务，消费者1去队列中获取 偶数 序列的任务。

channel.basic_qos(prefetch_count=1) 表示谁来谁取，不再按照奇偶数排列

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.61.131'))
channel = connection.channel()

# make message persistent
channel.queue_declare(queue='hello1', durable=True)


def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    import time
    time.sleep(10)
    print('ok')
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)    #实现随来随取

channel.basic_consume(callback,
                      queue='hello1',
                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

#消费者

重点说明

a、使用工作队列的一个好处就是能够并行的处理队列。如果任务堆积，只需要添加更多的工作者work即可

b、对于多个work，RabbitMQ会按照顺序把消息发送给每个消费者，这种方式为轮询(round-robin)

c、消息响应：如果一个work挂掉，上面代码实现将这个消息发送给其他work，而不是丢弃。

     因此需要消息响应机制，每个work处理完成任务的时候，会发送一个ack，告诉RabbitMQ-server已经收到并处理某条消息，然后RabbitMQ-server释放并删除这条消息。

d、消息ack没有超时的概念，这样在处理一个非常耗时的消息任务时候就不会出现问题

e、消息ack默认是开启的，通过no_ack=True标识关闭，在回调函数中basic_ack中

f、如果忘记调用basic_ack的话，这样消息在程序退出后重新发送，会导致RabbitMQ-server中消息堆积，占用越来越多的内存。通过如下命令进行确认:

[root@localhost sbin]# ./rabbitmqctl list_queues name messages_ready messages_unacknowledged
Listing queues ...
hello   0       0
hello1  3       0
hello34 0       0
...done.

存在三个堆积的任务

g、关于队列大小：如果所有的工作者都在处理任务，队列就会被填满。需要留意这个问题，要么添加更多的工作者，要么使用其他策略，例如设置队列大小等。

4、发布订阅　　　

发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。

 exchange type = fanout

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='logs',
                         type='fanout')

message = "info: Hello World!"
channel.basic_publish(exchange='logs',
                      routing_key='',
                      body=message)
print(" [x] Sent %r" % message)
connection.close()

# 发布者

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='logs',
                         type='fanout')

result = channel.queue_declare(exclusive=True) #队列断开后自动删除临时队列
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()

5、关键字发送

 exchange type = direct

之前事例，发送消息时明确指定某个队列并向其中发送消息，RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange，exchange根据 关键字 判定应该将数据发送至指定队列。

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs_test',
                         type='direct')

severity = 'error'
message = 'qwe'
channel.basic_publish(exchange='direct_logs_test',
                      routing_key=severity,
                      body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

#生产者

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs_test',
                         type='direct')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

severities = ['info']      #只消费info
if not severities:
    sys.stderr.write("Usage: %s [info] [error]
" % severities)
    sys.exit(1)

for severity in severities:
    channel.queue_bind(exchange='direct_logs_test',
                       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()

#消费者

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs_test',
                         type='direct')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

severities = ['error', 'info']                  #可以消费error 和info的
if not severities:
    sys.stderr.write("Usage: %s [error]
" % severities)
    sys.exit(1)

for severity in severities:
    channel.queue_bind(exchange='direct_logs_test',
                       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()

#消费者

6、模糊匹配

 exchange type = topic

在topic类型下，可以让队列绑定几个模糊的关键字，之后发送者将数据发送到exchange，exchange将传入”路由值“和 ”关键字“进行匹配，匹配成功，则将数据发送到指定队列。

• # 表示可以匹配 0 个 或 多个 单词
• *  表示只能匹配 一个 单词

发送者路由值              队列中

old.boy.python          old.*  -- 不匹配

old.boy.python          old.#  -- 匹配

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',
                         type='topic')

routing_key = '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()

# 生产者

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.61.131'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',
                         type='topic')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

binding_keys = ['*.info', ]                  #模糊查询
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()

# 消费者