寄存器：运行时间快，但是容量比较小
一 守护进程
1 什么是守护进程：
守护进程就是辅助主进程的代码的执行，守护进程会伴随着主进程的代码的运行周期的。主进程的代码执行完毕之后，守护进程就没有存在的必要，所以守护进程会在主进程代码执行完毕之后自动终止。
守护进程中是无法在开启其他的子进程，否则就会抛出异常。
2 创建一个守护进程：
daemon=True：创建守护进程，daemon默认等于False。
实例1：
# import multiprocessing
# import time
# def walk(n):
# print('>>>>>>start',n)
# time.sleep(3)
# print('>>>>>>end',n)
# if __name__=='__main__':
# p1=multiprocessing.Process(target=walk,args=(2,))
# p2=multiprocessing.Process(target=walk,args=(4,))
# p1.daemon=True
# p1.start()
# p2.start()
# print('执行完毕')
实例2：
# import multiprocessing
# import time
# def walk(n):
# print('>>>>>>start',n)
# time.sleep(3)
# print('>>>>>>end',n)
# if __name__=='__main__':
# p1=multiprocessing.Process(target=walk,args=(2,))
# p2=multiprocessing.Process(target=walk,args=(4,))
# p1.daemon=True
# p1.start()
# p2.start()
# time.sleep(2)
# print('执行完毕')
实例3 ：
# import multiprocessing
# import time
# def walk(n):
# print('>>>>>>start',n)
# time.sleep(3)
# print('>>>>>>end',n)
# if __name__=='__main__':
# p1=multiprocessing.Process(target=walk,args=(2,))
# p2=multiprocessing.Process(target=walk,args=(4,))
# p1.daemon=True
# p1.start()
# p2.start()
# print('执行完毕')
# time.sleep(0.1)
注意：进程和进程之间是相互独立的，只要主进程中的代码没有执行完，守护进程中的代码还是会被执行的。
二 同步锁也叫互斥锁
同步锁的作用是：把并发变成串行，将竞争变得有序化
Lock：锁
acquire：加上锁
release：解锁
如下：
import multiprocessing
import json
import random
import time
json.dump({'count':10},open('a.txt','w'))
time.sleep(1)
def wolk(n):
ret=json.load(open('a.txt'))
print('<%s> 查看还剩%s张票'%(n,ret['count']))
def foo(n):
ret=json.load(open('a.txt'))
if ret['count']>0:
x=random.randint(1,5)
if x>ret['count']:
x = ret['count']
ret['count'] -= x
time.sleep(0.2)
json.dump(ret, open('a.txt', 'w'))
print('%s 购买了%s张票' % (n, x))
def wolk_foo(n,lock):
wolk(n)
lock.acquire()
foo(n)
lock.release()
if __name__=='__main__':
lock=multiprocessing.Lock()
for j in range(20):
p=multiprocessing.Process(target=wolk_foo,args=(j,lock))
p.start()
with 锁：自动加上锁，执行完毕过后自动解开锁。 如下：
# import multiprocessing
# import json
# import random
# import time
# json.dump({'count':10},open('a.txt','w'))
# time.sleep(1)
# def wolk(n):
# ret=json.load(open('a.txt'))
# print('<%s> 查看还剩%s张票'%(n,ret['count']))
# def foo(n):
# ret=json.load(open('a.txt'))
# if ret['count']>0:
# x=random.randint(1,5)
# if x>ret['count']:
# x = ret['count']
# ret['count'] -= x
# time.sleep(0.2)
# json.dump(ret, open('a.txt', 'w'))
# print('%s 购买了%s张票' % (n, x))
#
# def wolk_foo(n,lock):
# wolk(n)
# with lock:
# foo(n)
# if __name__=='__main__':
# lock=multiprocessing.Lock()
# for j in range(20):
# p=multiprocessing.Process(target=wolk_foo,args=(j,lock))
# p.start()
加上锁是为了实现串行，保证代码的安全性，但是减低了代码的执行效率
注意：在 这两个实例中，最开始dump文件的时候是需要一段时间的（也就是I/O阻塞），所以在dump文件的后睡上一段时间，假如不加上睡眠时间，文件数据就会错乱或者报错。
三 IPC机制
IPC机制就是进程之间的相互通信，分别有两种方式：一种是队列，另一种是管道
队列的原理是：先进先出，只能是一头传入数据，另一头读取数据。管道+锁就能实现队列。
管道的原理是：
队列和管道实现了多个进程之间的共享内存空间。
Queue：指定队列中存放的数据个数。
put：写入数据
get：读取数据
import multiprocessing q=multiprocessing.Queue(5) q.put(111) q.put(222) q.put(333) q.put(444) q.put(555) print(q.get()) print(q.get()) print(q.get()) print(q.get()) print(q.get())
注意：如果put 和 get 超出了定义存放的个数，就会阻塞
put_nowait：上传数据，如果超出了存放数据的个数就会抛出异常
get_nowait：读取数据，如果超出了存放数据的个数就会抛出异常
import multiprocessing q=multiprocessing.Queue(5) q.put_nowait(1) q.put_nowait(2) q.put_nowait(3) q.put_nowait(4) q.put_nowait(5) print(q.get_nowait()) print(q.get_nowait()) print(q.get_nowait()) print(q.get_nowait()) print(q.get_nowait())
四 生产者和消费者
生产者：创建数据
消费者：读取（处理）数据
生产者和消费者都是由都列分离开的。
生产者创建数据，然后存放到队列里面，接着消费者在队列里面读取数据
import multiprocessing
import random
import time
def producer(q):
for i in range(1,30):
time.sleep(random.random())
q.put('包子%s'%i)
print('厨师%s创建了包子%s'%('egon'+str(random.randint(1,5)),i))
def consumer(q):
while True:
ret=q.get()
if ret is None:break
time.sleep(random.random())
print('%s吃了包子%s'%('alex'+str(random.randint(1,5)),ret))
if __name__=='__main__':
q = multiprocessing.Queue()
c_s=multiprocessing.Process(target=producer,args=(q,))
x_f=multiprocessing.Process(target=consumer,args=(q,))
c_s.start()
x_f.start()
c_s.join()
q.put(None)
注意：在消费者执行完过后需要加上一个终止条件，不然代码就会一直在那里等待着。
处理生产者和消费者直接的数据平衡的速度差
如何平衡：生产者--------》队列-------》消费者 （生产者和消费者解耦）
