一.进程间通信
1.进程间通信之队列：先进先出
1 from multiprocessing import Queue 2 3 q = Queue(5) #参数表示的是队列的最大存储数 4 #往队列中添加数据 5 q.put(1) 6 q.put(2) 7 print(q.full()) #q.full()是判断队列是否满了 8 q.put(3） 9 q.put(4) 10 q.put(5) 11 print(q.full()) 12 13 #q.put(6) 这个时候 队列满了 会原地等待 直到队列中有数据出来 才会执行#（阻塞态） 14 15 print(q.get()) #从队列中取数据 先进先出 如果队列中没有数据 会等待程#序会进入阻塞，直到队列中有数据放入 16 print(q.get_nowait()) #取值 没有值不等待直接报错 17 #full get_nowait 都不适用于多进程的情况
2.进程间通信IPC机制
1 from multiprocessing import Process,Queue
2
3 def producer(q):
4 q.put('hello world!')
5
6 def consumer(q):
7 print(q.get())
8
9 if __name__ == '__main__':
10 q = Queue()
11 p = Process(target = producer,args = (q,))
12 p.start()
13 c = Process(target = consumer,args = (q,))
14 c.start()
15
3.生产者与消费者模型****
生产者：生产制造数据的
消费者：消费处理数据的
下面举个做包子与买包子的例子：
1 from multiprocessing import Process, Queue,JoinableQueue
2 import random
3 import time
4
5 def producer(name,food,q):
6 for i in range(5):
7 data = '%s生产了%s'%(name,food)
8 time.sleep()
9 q.put(data)
10 print(data)
11
12 def consumer(name,q):
13 while True:
14 data = q.get()
15 if not data:
16 break
17 print('%s吃了%s'%(name,data))
18 time.sleep(random.random())
19 q.task_done() #告诉队列你已经从队列中去一个数据 并且处理完毕了
20
21 if __name__ == '__main__':
22 q = JoinableQueue()
23 p = Process(target = producer,args = ('egon','馒头',q))
24 p1 = Process(target = producer,args = ('tank','生蚝',q))
25 c = Process(target = consumer,args = ('jerry',q))
26 c1 = Process(target = consumer,args = ('jason',q))
27 p.start()
28 p1.start()
29 c.daemon = True
30 c1.daemon = True
31 c.start()
32 c1.start()
33 p.join()
34 p1.join()
35
36 q.join() #等待队列里面数据全部取出
二.线程
1.什么是线程?
进程线程其实都是虚拟单位，都是用来帮助我们形象的描述具体事物
进程:资源单位
线程：执行单位
将内存比喻成工厂，那么进程就相当于工厂里的车间
而你的线程就相当于是车间里面的流水线
Ps:每个进程都自带一个线程， 线程才是真正的执行单位，进程只是再线程运行过程中
提供代码运行所需要的资源
2.为什么有线程
开进程
1.申请内存空间 耗资源
2.拷贝代码 耗资源
开线程
一个进程内可以起多个线程，并且线程与线程之间数据是共享的
Ps:开启的线程的开销要远远小于开启进程的开销
3.创建线程的两种方式
1 from threading import Thread
2 import time
3 def task(name):
4 print('%s is running' %name)
5 time.sleep(3)
6 print('%s is over'%name)
7
8 t = Thread(target = task,args('egon',))
9 t.start()
10 print('主')
1 from threading import Thread
2 import time
3
4 class MyThread():
5 def __init__(self,name):
6 super().__init__()
7 self.name = name
8
9 def run(self):
10 print('%s is running'%self.name)
11 time.sleep(3)
12 print('%s is over'%self.name)
13
14 t = MyThread('egon')
15 t.start()
16 print('主')
4.线程对象及其他方法
1 from threading import Thread,current_thread,active_count
2 import os
3 import time
4
5 def test(name):
6 print('%s is running' %name)
7 print('子 current_thread',current_thread().name)
8 print('子',os.getpid())
9 time.sleep(3)
10 print('%s is over'%name)
11
12 t = Thread(target = test,args =('egon'))
13 t1 = Thread(target = test,args =('egon1'))
14 t.start()
15 t1.start()
16
17 t.join()
18 t1.join() #主线程等待子线程运行完毕
19
20 print('当前正在活跃的线程数:',active_count())
21 print('主')
5.线程间通信
线程间数据是共享的
1 from threading import Thread 2 3 n = 666 4 5 def test(): 6 global n 7 n = 999 8 9 t = Thread(target = test) 10 t.start() 11 t.join() 12 print(n) #结果是 999
线程互斥锁
from threading import Thread,Lock
import time
n = 100
def test(mutex):
global n
mutex.acquire()
tmp = n
n = tmp-1
mutex.release()
t_list = []
mutex = Lock()
for i in range(100):
t = Thread(target = test,args=(mutex,))
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(n)
6.守护线程
主线程的结束意味着这进程的结束
主线程要等待所有非守护子线程结束才能结束
1 from threading import Thread,current_thread
2 import time
3
4 def test(i):
5 print(current_thread().name)
6 time.sleep(i)
7 print('GG')
8
9 for i in range(3):
10 t = Thread(target = test,args = (i,))
11 t.daemon = True
12 t.start()
13 print('主')
例子：
from threading import Thread
import time
def foo():
print(123)
time.sleep(1)
print('end123')
def bar():
print(456)
time.sleep(3)
print('end456')
if __name__ == '__main__':
t1 = Thread(target = foo)
t2 = Thread(target = bar)
t1.daemon = True
t1.start()
t2.start()
print('main-------------')
#执行结果123
456
main-------------
end123
end456
来源：https://www.cnblogs.com/s686zhou/p/11345454.html