并发通信Manage，队列， 互斥锁

目录

Manage

队列  先入先出

互斥锁

---

Manage

进程间的通信是被限制的

from multiprocessing import Process

a = 1

def func():
    global a    # 声明全局变量
    a = 2    # 修改全局变量

func()
print(a)

p = Process(target=func)
p.start()
p.join()
print(a)

两个结果，第一个是2，第二个是1-----> 进程内存空间是独立的

解决方案：开辟一个新的进程空间，通过代理器和管理器进行通信

　　1， 管理器负责与公共进程通信

　　2， 代理负责操作共享空间

from multiprocessing import Process, Manage(管理器)

mgr = Manage() # 先开启一个子进程（守护进程），并且返回一个用来通信的管理器

shared_list = mgr.list()    # 通过Manage管理器开启一个公共l列表空间（代理）

def func(lis):
    lis.appent('hello')

p = Process(target=func, args=(shared_list, ))
p.start(0
p.join()

print(shared_list)

--> ['hello']

　　这里需要知道，可以开启的代理空间有以下几个：

　　　　　　mgr.list()    列表

　　　　　　mgr.dict()    字典

　　　　　　mgr.Queue()    队列

---

队列    先入先出

队列操作：

　　入列：put()

　　出列：get()

　　测试空：empty()  近似值

　　测试满：funll()  近似值

　　队列长度：qsize()  近似值

　  任务结束： task_done()

　　等待完成：join()

　　  需要了解的是，队列中存在一个计数器的概念，当put的时候，计数器会加1，当task_done时，计数器减1

　　  可以用join进行测试，当计数器不是0，队列会阻塞，只有当计数器为0时，才会解阻塞

---

 互斥锁

线程间的通信不存在限制，但是会存在资源竞争的问题，即同时执行的线程，公用共享资源的时候，会抢占资源，导致数据乱序

所以需要互斥锁来锁定某些操作

在python的原始解释器Cpython中存在着GIL(Global Interpreter Lock，全局解释器锁)因此在解释器执行Python代码

时，会产生互斥锁来限制线程对共享资源的访问，直到解释器遇到I/O操作或者操作次数达到一定数目才会释放GIL。

import threading from Thread, Lock

lock = Lock() # 实例化一个锁

      with lock:
            xxxxxxxx
'''
或者：
lock.acquire() # 上锁
xxxxxxxx
lock.release() # 解锁

xxxxxx能少则少
锁不能加太多，会大大下降性能
'''

 from threading import Thread, Lock

 lock = Lock()   # 实例化一个锁的实例
 a = 0

 def incr(n):　　# 自加
     global a
     for i in range(n):
         with lock:
             a += 1

 def decr(n):　　# 自减
     global a
     for i in range(n):
         with lock:
             a -= 1

 t = Thread(target=incr, args=(1000000, ))
 t2 = Thread(target=decr, args=(1000000, ))
 t.start()
 t2.start()
 t.join()
 t2.join()
 print(a)

 --> 0

如果不加锁，线程之间会竞争资源，得到的结果是一个随机值