进程线程之间的通信

多进程之间有各自的内存空间，多线程是共享同一个线程的空间

多进程之间的通信

from multiprocessing import Process, Manager


def func(li):
    li.append(1)


if __name__ == "__main__":
    mgr = Manager() #（共享内存）管理器接口
    # 代理
    shared_list = mgr.list() # 在公共进程Manage中开启一个list空间，用来进程通信
    # mgr.dict()
    # mgr.Queue()
    p = Process(target=func, args=(shared_list, ))
    p.start()
    p.join()

    print(shared_list)

多线程之间的通信

from threading import Thread


a = []
def fun(a):
    a.append(1)

t = Thread(target=fun, args=(a, ))
t.start()
t.join()

print(a)

多线程大数据通信紊乱

线程共享内存的竞争问题，a=0, t1 -> 0 + 1(尚未将结果复制给a, 切换线程至t2)， t2 ->   此时a依然为 a=0, 执行0-1并复制给a=-1, 切回t1继续执行,复制给a=1。  

""" 线程之间的通信 """
from threading import Thread


a = 0

def incr(n):
    global a
    for i in range(n):
        a += 1

def decr(n):
    global a
    for i in range(n):
        a -= 1


t1 = Thread(target=incr, args=(100000, ))
t2 = Thread(target=decr, args=(100000, ))
t1.start()
t2.start()
t1.join()
t2.join()
print(a) # 数据大，结果不固定，不为0

解决内存竞争问题，通过线程的互斥锁来控制（但是会增加性能消耗，尽量只在必要的地方加锁）

# -*- coding: utf-8 -*-
""" 线程之间的通信 """
from threading import Thread, Lock


lock = Lock()
a = 0

def incr(n):
    global a
    for i in range(n):
        lock.acquire() # 上锁
        a += 1
        lock.release() # 解锁

def decr(n):
    global a
    for i in range(n):
        with lock: # 上锁,解锁
            a -= 1


t1 = Thread(target=incr, args=(100000, ))
t2 = Thread(target=decr, args=(100000, ))
t1.start()
t2.start()
t1.join()
t2.join()
print(a) # 结果为0

一进程与另一个进程中的线程通信，也是通过Manage先进行进程之间的通信。

进程线程通信安全之队列（先进先出）数据结构， 生产者消费者模式