一、互斥锁
进程之间数据隔离，但是共享一套文件系统，因而可以通过文件来实现进程直接的通信，但问题是必须自己加锁处理。
注意：加锁的目的是为了保证多个进程修改同一块数据时，同一时间只能有一个修改，即串行的修改，没错，速度是慢了，牺牲了速度而保证了数据安全。
1.上厕所的小例子：你上厕所的时候肯定得锁门吧，有人来了看见门锁着，就会在外面等着，等你吧门开开出来的时候，下一个人才去上厕所。
1 from multiprocessing import Process,Lock
2 import os
3 import time
4 def work(mutex):
5 mutex.acquire()
6 print('task[%s] 上厕所'%os.getpid())
7 time.sleep(3)
8 print('task[%s] 上完厕所'%os.getpid())
9 mutex.release()
10 if __name__ == '__main__':
11 mutex = Lock()
12 p1 = Process(target=work,args=(mutex,))
13 p2 = Process(target=work,args=(mutex,))
14 p3 = Process(target=work,args=(mutex,))
15 p1.start()
16 p2.start()
17 p3.start()
18 p1.join()
19 p2.join()
20 p3.join()
21 print('主')
二、模拟抢票（也是利用了互斥锁的原理 ：LOCK互斥锁）
1 import json
2 import time
3 import random
4 import os
5 from multiprocessing import Process,Lock
6 def chakan():
7 dic = json.load(open('piao',)) # 先查看票数，也就是打开那个文件
8 print('剩余票数：%s' % dic['count']) # 查看剩余的票数
9 def buy():
10 dic = json.load(open('piao',))
11 if dic['count']>0: #如果还有票
12 dic['count']-=1 #就修改里面的值-1
13 time.sleep(random.randint(1,3)) #执行里面买票的一系列操作就先不执行了，让睡一会代替（并且随机的睡）
14 json.dump(dic,open('piao','w'))
15 print('%s 购票成功' % os.getpid()) # 当前的那个id购票成功
16 def task(mutex): #抢票
17 chakan() #因为查看的时候大家都可以看到，不需要加锁
18 mutex.acquire() #加锁
19 buy() #买的时候必须一个一个的买，先等一个人买完了，后面的人在买
20 mutex.release() #取消锁
21 if __name__ == '__main__':
22 mutex = Lock()
23 for i in range(50):#让50个人去访问那个票数
24 p = Process(target=task,args=(mutex,))
25 p.start()
三、Process对象的其他属性
p.daemon ：守护进程（必须在开启之前设置守护进程）：如果父进程死，子进程p也死了
p.join：父进程等p执行完了才运行主进程，是父进程阻塞在原地，而p仍然在后台运行。
terminate：强制关闭。（确保p里面没有其他子进程的时候关闭，如果里面有子进程，你去用这个方法强制关闭了就会产生僵尸进程（打个比方：如果你老子挂了，你还没挂，那么就没人给你收尸了，啊哈哈））
is_alive：关闭进程的时候,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
p.join()：父进程在等p的结束，是父进程阻塞在原地，而p仍然在后台运行
p.name：查看名字
p.pid ：查看id
我们可以简单介绍一下僵尸进程：
子进程运行完成，但是父进程迟迟没有进行回收，此时子进程实际上并没有退出，其仍然占用着系统资源，这样的⼦进程称为僵尸进程。
因为僵尸进程的资源一直未被回收，造成了系统资源的浪费，过多的僵尸进程将造成系统性能下降，所以应避免出现僵⼫进程。
1 from multiprocessing import Process
2 import os
3 import time
4 def work():
5 print('%s is working'%os.getpid())
6 time.sleep(3)
7 if __name__ == '__main__':
8 p1 =Process(target=work)
9 p2 =Process(target=work)
10 p3 =Process(target=work)
11 # p1.daemon = True
12 # p2.daemon = True #守护进程(守护他爹)
13 # p3.daemon = True #主进程死了子进程也死了（就不会执行子进程了）
14 p1.start()
15 p2.start()
16 p3.start()
17
18 p3.join()
19 p2.join()
20 p1.join() #多个join就是在等花费时间最长的那个运行完就执行主程序了
21 print('主程序')
22
23 # -了解方法---------------
24 # p1.terminate() #强制关闭进程
25 # time.sleep(3)
26 # print(p1.is_alive()) #看是不是还活着
27 # print(p1.name) #查看进程名字
28 # print(p1.pid) #查看id号
29 # print('主程序')
三、进程间的三种通信（IPC）方式：
方式一：队列（推荐使用）
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
1.队列：队列类似于一条管道，元素先进先出
需要注意的一点是：队列都是在内存中操作,进程退出,队列清空,另外,队列也是一个阻塞的形态
2.队列分类
队列有很多种，但都依赖与模块queue
queue.Queue() #先进先出
queue.LifoQueue() #后进先出
queue.PriorityQueue() #优先级队列
queue.deque() #双线队列
创建队列的类（底层就是以管道和锁定的方式实现）：
|
1
2
|
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。 |
参数介绍：
|
1
|
1 maxsize是队列中允许最大项数，省略则无大小限制。
|
方法介绍：
|
1
2
3
4
5
6
7
8
9
|
q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
q.get_nowait():同q.get(False)
q.put_nowait():同q.put(False)
q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样 |
应用：
1 # 1.可以往队列里放任意类型的 2 # 2.先进先出 3 from multiprocessing import Process,Queue 4 q= Queue(3) 5 q.put('first') #默认block=True 6 q.put('second') 7 q.put('third') 8 9 print(q.get()) 10 print(q.get()) 11 print(q.get())