ThreadLocal、进程VS线程、分布式进程

1.ThreadLocal变量是一个全局变量，每个线程只能读取自己的独立副本，ThreadLocal解决了一个线程中各个函数之间的传递问题

import threading
local_school = threading.local()
def process_school():
  std = local_school.student
  print('Hello,%s(in %s)' % (std,threading.currenr_thread().name))
def process_thread(name):
  local_school.student = name
  process_school()
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()

2.进程Vs线程

1)为实现多任务，采用Master-worker模式，Master分配任务，Worker执行任务，通常情况下都是一个Master多个Worker

2)多线程（进程）主线程是Master，其他线程是Worker

3）多进程稳定性高，但是创建开销大

4）多线程稳定性不好，一个崩溃，全部线程崩溃

3.计算密集型和IO密集型

多任务的两种类型一种是计算机密集型，另外一种是IO密集型

计算机密集型，任务多时，切换时间长，CPU利用率低，适合C语言

IO密集型，任务多时，CPU利用率高，适合脚本语言（Python）

3.异步IO

实现单线程执行多任务模式叫做事件驱动模型，python中的单线程异步叫做协程

4.分布式进程

1)task.master分配任务

第一步导入threading random,time,queue

from multiprocessing.Manager import BaseManager

第二步创建两个Queue对象分别是发送队列以及接收队列

第三步创建QueueManager类，父类是BaseManager

第四步通过QueueManager登录对象来方便网络获取信息，传入get_task_queue方法，传入callable函数

第五步传入网络地址，创建线程，再启动线程，

第六步创建发送变量以及接收变量

最后一步传入信息以及获取信息

import random,time,queue
from multiprocessing.managers import BaseManager
#发送任务队列
task_queue = queue.Queue()
#接受任务队列
result_queue = queue.Queue()
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(1000):
  n = random.randint(0,10000)
  print('Put task %d...' % n)
  task.put(n)
#从result队列读取结果
print('Try get result...')
for i in range(10):
  r = result.get(timeout = 10)
  print('Result:%s' % r)
#关闭：
manager.shutdown()
print('master.exit.')

2）task.worker(执行任务)

将第五部里面的启动线程改为连接线程就OK

import time,sys,queue
from multiprocessing.managhers 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 = QueueMaster(address=(server_addr,5000),authkey=b'abc')
#从网络连接
m.connect()
#获取Queue对象
task = m.get_task_queue()
result = m.get_resulr_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:
    print('task queue is empty.')
#处理结果
print('Worker exit.')

3）分布式进程实现了一个master可以分配多个Worker执行任务，通过修改接口，方便作用于多个机器中