python 20151227

threadlocal

• 在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量要好，因为局部变量只有自己能看见，不会影响其他的现成，而全局变量的使用必须加锁。
• 局部变量传递比较麻烦
• threadlocal

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

执行结果为：

Hello, Alice (in Thread-A)
Hello, Bob (in Thread-B)

• 全局变量local_school就是一个threadlocal 对象。每个thread对它都可以读写student 属性，但是互不影响。
• 全局变量local_school是一个dict
• threadlocal 最常用的地方是为每个线程绑定一个数据库连接，http请求，用户身份信息等。这样每个线程所有调用到的处理函数都可以非常方便的访问这些资源。

进程vs线程

要实现多任务，通常会设计master-worker模式，master负责分配任务，worker负责执行任务。所以，在多任务环境下，通常是一个master，多个worker。

• 线程切换
• 计算密集型 vs IO密集型
  
  • 计算密集型：进行大量的计算，消耗cpu资源
  • IO密集型：涉及到网络、磁盘IO的任务都是IO密集型。CPU消耗很少，任务的大部分时间都是在等待IO操作完成
• 异步IO

分布式进程

python的multiprocessing 模块不仅支持多进程，其中managers子模块还支持把多进程分不到多台机器上。一个服务进程可以作为调度者，将任务分不到其他多个进程中，依靠网络通信。

# task_master.py

import random, time, queue
from multiprocessing.managers import BaseManager

# 发送任务的队列:
task_queue = queue.Queue()
# 接收结果的队列:
result_queue = queue.Queue()

# 从BaseManager继承的QueueManager:
class QueueManager(BaseManager):
    pass

# 把两个Queue都注册到网络上, callable参数关联了Queue对象:
QueueManager.register('get_task_queue', callable=lambda: task_queue)
QueueManager.register('get_result_queue', callable=lambda: result_queue)
# 绑定端口5000, 设置验证码'abc':
manager = QueueManager(address=('', 5000), authkey=b'abc')
# 启动Queue:
manager.start()
# 获得通过网络访问的Queue对象:
task = manager.get_task_queue()
result = manager.get_result_queue()
# 放几个任务进去:
for i in range(10):
    n = random.randint(0, 10000)
    print('Put task %d...' % n)
    task.put(n)
# 从result队列读取结果:
print('Try get results...')
for i in range(10):
    r = result.get(timeout=10)
    print('Result: %s' % r)
# 关闭:
manager.shutdown()
print('master exit.')

在一台机器上写多进程程序时，创建的queue可以直接拿来用。但是在分布式多进程环境下，添加到queue的任务不可以直接对原始的task_queue进行操作，那样就绕过了queuemanager的封装，补习通过manager.get_task_queue（）来获得的queue接口添加

在另一台机器上气功任务进程

# task_worker.py

import time, sys, queue
from multiprocessing.managers import BaseManager

# 创建类似的QueueManager:
class QueueManager(BaseManager):
    pass

# 由于这个QueueManager只从网络上获取Queue，所以注册时只提供名字:
QueueManager.register('get_task_queue')
QueueManager.register('get_result_queue')

# 连接到服务器，也就是运行task_master.py的机器:
server_addr = '127.0.0.1'
print('Connect to server %s...' % server_addr)
# 端口和验证码注意保持与task_master.py设置的完全一致:
m = QueueManager(address=(server_addr, 5000), authkey=b'abc')
# 从网络连接:
m.connect()
# 获取Queue的对象:
task = m.get_task_queue()
result = m.get_result_queue()
# 从task队列取任务,并把结果写入result队列:
for i in range(10):
    try:
        n = task.get(timeout=1)
        print('run task %d * %d...' % (n, n))
        r = '%d * %d = %d' % (n, n, n*n)
        time.sleep(1)
        result.put(r)
    except Queue.Empty:
        print('task queue is empty.')
# 处理结束:
print('worker exit.')