6.1 创建线程
有两种方式创建一个线程，一种是实例化Thread，并传参；另一种是通过继承Thread，实现run方法。
from threading import Thread
def test(x):
print(x)
t = Thread(target=test, args=("dai",))
t.start()
class Test(Thread):
def __init__(self, value):
Thread.__init__(self)
self.value = value
def run(self):
test(self.value)
t = Test("blue")
t.start()
thread = []
for i in range(1, 11):
t = Test(i)
thread.append(t)
t.start()
for t in thread:
t.join()
print("main thread")
其中，join方法让主线程等待子线程结束。
对于python来说，多线程只适用于I/O密集型操作，不适用与CPU密集型操作。所谓I/O密集型操作类似于文件读写和网络相关，CPU密集型操作类似于复杂计算等。其主要的原因是python解释器有GIL锁的限制，不能将任务分配给多个处理器同时操作，所以对于在python中的线程来说，是一个美丽的梦。
6.2 线程间通信
线程中的通信可以通过共享消息队列来实现，在同一进程中，实例可以被多线程访问，但是需要注意的是同时访问需要一种线程安全的数据结构，要使用queue库中的Queue。
下面的实例中，生产者模拟I/O操作，消费者对生产者的结果进行处理，两者之间通过Queue进行通信。
from threading import Thread
from time import sleep
from queue import Queue
class Producer(Thread):
def __init__(self, sid, queue):
Thread.__init__(self)
self.queue = queue
self.sid = sid
def run(self):
self.work()
self.queue.put((self.sid, 'Producer'+str(self.sid)))
def work(self):
sleep(2)
print("Producer work" + str(self.sid))
class Consumer(Thread):
def __init__(self, queue):
Thread.__init__(self)
self.queue = queue
def run(self):
while True:
sid, data = self.queue.get()
if sid == -1:
break
if data:
print("Consumer received " + str(data))
if __name__ == "__main__":
q = Queue()
p_threads = [Producer(i, q) for i in range(1, 11)]
c_thread = Consumer(q)
for t in p_threads:
t.start()
c_thread.start()
for t in p_threads:
t.join()
q.put((-1, None))
在生产者中处理work逻辑，并将数据写入到queue中，在消费者中一直死循环，消费掉queue中的数据。在main方法中启动10个生产者线程，开始工作，然后在任务都处理结束之后，设置queue的值-1让消费者跳出循环，结束程序。
6.3 线程事件通知
在python中可以通过threading库中的Event来控制线程之间的事件通知。主要的方法有wait和set，分别代表等待和开始。
下面的实例继续使用6.2中的生产者-消费者的实例进行扩展
from queue import Queue
from threading import Thread, Event
from time import sleep
class Producer(Thread):
def __init__(self, sid, queue):
Thread.__init__(self)
self.queue = queue
self.sid = sid
def run(self):
self.work()
self.queue.put((self.sid, 'Producer' + str(self.sid)))
def work(self):
sleep(2)
# print("Producer work" + str(self.sid))
class Consumer(Thread):
def __init__(self, queue, s_event, r_event):
Thread.__init__(self)
self.queue = queue
self.s_event = s_event
self.r_event = r_event
def run(self):
count = 0
while True:
sid, data = self.queue.get()
if sid == -1:
self.r_event.set()
self.s_event.wait()
break
if data:
count += 1
print("Consumer received " + str(data))
if count == 3:
self.r_event.set()
self.s_event.wait()
self.s_event.clear()
count = 0
class Service(Thread):
def __init__(self, s_event, r_event):
Thread.__init__(self)
self.s_event = s_event
self.r_event = r_event
self.setDaemon(True)
def work(self):
sleep(2)
print("Service work")
def run(self):
while True:
self.r_event.wait()
self.work()
self.r_event.clear()
self.s_event.set()
if __name__ == "__main__":
q = Queue()
p_threads = [Producer(i, q) for i in range(1, 11)]
s_event = Event()
r_event = Event()
c_thread = Consumer(q, s_event, r_event)
service_thread = Service(s_event, r_event)
service_thread.start()
for t in p_threads:
t.start()
c_thread.start()
for t in p_threads:
t.join()
q.put((-1, None))
可以看出，新建了一个Service的服务线程，每当消费者线程执行了三次就会调用服务线程一次，等待服务线程执行完一次之后继续在消费者线程继续执行，当消费者线程结束之后，服务线程也随之结束。
分析这段程序，在消费者线程中处理了三次就会让r_event处于触发状态，此时服务线程一直在死循环并接收到了r_event的状态，之后执行服务线程中的work方法。当服务线程处理结束后，会让s_event处于触发状态，在消费者的线程中接收到此事件将count重新归0开始新的循环。
clear方法主要的作用是让事件传递能够一直发生。setDaemon(True)以为着此线程为守护线程，当依赖的线程结束后，此线程也将结束。
6.4 线程本地数据
在一些场景下，对于所有线程都有一个共同的属性，但是这个属性的值每个进程都不相同，并且无法修改其他进程此属性的值，这种情况下可以使用线程本地数据来解决。
from threading import Thread, local
l = local()
l.x = 1
def f():
return print(l.x)
f()
t = Thread(target=f)
t.start()
可以看出在主线程中获取线程本地数据并新建属性x值为1，然后在主线程中调用f方法打印其值；接下来新建了一个子线程，调用f方法，但是报错，因为x属性只在主线程中，在子线程是无法进行调用的。
6.5 线程池
与java中的线程池原理类似，在python中也可以通过线程池来维护多个线程，需要使用的模块是标准库中concurrent.futures下的ThreadPoolExecutor。
from concurrent.futures import ThreadPoolExecutor
import time
excutor = ThreadPoolExecutor(3)
def f(a, b):
time.sleep(5)
return a ** b
result = excutor.submit(f, 2, 3)
print(result.result())
for x in excutor.map(f, [2, 4, 6], [3, 5, 7]):
print(x)
for x in excutor.map(f, [2, 4, 6, 8, 10], [3, 5, 7, 9, 11]):
print(x)
在上面的实例中，对ThreadPoolExecutor实例化时传入需要线程池中线程的个数，通过submit方法传入所调用方法名和参数，返回值执行result可以得出每个线程的结果返回值。通过map方法，可以对多个线程进行调用、赋值，当启动的线程超过3个时，后面的线程处于等待状态，让线程池中的三个线程处理完成后再分配给后面的线程。
6.6 多进程
python的多进程操作可以使用标准库中的multiprocessing，启动一个进程的方法和启动一个线程方法相似，下面主要看进程之间的通信方式。
进程间的通信方式主要有两种方式，一种是通过multiprocessing中的Queue，一种是通过multiprocessing中的Pipe。
首先来看通过Queue的方式。在线程间通信时提到过，当时所用的也是Queue数据接口，只不过是queue标准库中的，其实两者之间差异不大，使用方法也比较类似。
from multiprocessing import Process, Pipe, Queue
q = Queue()
def f(q):
print('start')
print(q.get())
print('end')
if __name__ == "__main__":
Process(target=f, args=(q,)).start()
q.put(2)
在main方法中启动一个进程，然后调用f方法，传入的是在主进程中实例化的Queue对象。在f方法中，子进程调用q.get方法等待接收事件信息，此时处于block状态。当在main方法中，主进程调用到了q.put方法给子进程传入事件，此时f方法就可以继续执行了。
Pipe管道方式通信
通过管道的方式通信，可以做到两个进程之间的双向通信。
from multiprocessing import Process, Pipe, Queue
q = Queue()
p1, p2 = Pipe()
def f_pipe(p):
p.send(p.recv() * 2)
def f_queue(q):
print('start')
print(q.get())
print('end')
if __name__ == "__main__":
# Process(target=f, args=(q,)).start()
# q.put(2)
Process(target=f_pipe, args=(p2,)).start()
p1.send(55)
print(p1.recv())
在mian方法中启动了一个新的进程，并将管道的实例作为f_pipe方法的参数传入，之后在主进程中发送参数55传递给了子进程，然后子进程在f_pipe方法内处理完数据之后又将结果返回给了主进程。
