*并发通信*

进程通信隔离

进程间的隔离，可以看到在不同进程中，即使声明了全局变量，也还是没有作用

import multiprocessing

var = 10

def func():
    global var
    var += 1
    print('inner:', var)
    return var

p1 = multiprocessing.Process(target=func)
p1.start()
p1.join()

print('outer:', var)

进程信息共享
Manager是进程间通信的常用解决方案，通过公共空间来实现进程间的通信

import multiprocessing

mg = multiprocessing.Manager()  # 创建公共的服务器进程，并返回与其通信的肝理气


def fun(li):
    li.extend([1, 2, 3])


li_var = mg.list(('a', 'b', 'c'))  # 在进程中开辟一个列表（空间）

p1 = multiprocessing.Process(target=fun, args=(li_var,))
p1.start()
p1.join()

print(li_var)

线程信息共享
对于线程而言，它们始终在一个进程当中，因此共享同一个内存空间，因此可以访问主进程中的数据

import threading

var = 10


def func():
    global var
    var += 1
    print('inner:', var)
    return var


t1 = threading.Thread(target=func)
t1.start()
t1.join()

print('outer:', var)

线程之间资源抢占
这个时候出现资源错误，因为CPU计算是多条指令，组合运行的，所以在运行过程中如果插入其他指令，就会造成不可预见的结果

对于特殊资源，可以加上锁，来保护资源，确保每次操作的完整性

import threading

var = 10
lock = threading.Lock()  # 生成互斥锁


def f1():
    global var
    for i in range(1000000):
        lock.acquire()  #上锁
        var += 1
        lock.release()  #解锁
    return var


def f2():
    global var
    for i in range(1000000):
        lock.acquire()
        var -= 1
        lock.release()
    return var


t1 = threading.Thread(target=f1)
t2 = threading.Thread(target=f2)
t1.start()
t2.start()
t1.join()  # 确保子进程执行完毕才会执行下一个进程
t2.join()

print('outer:', var)

生产者和消费者模型-进程

import multiprocessing
import queue
import time


# 生产者
class Producer(multiprocessing.Process):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue

    def run(self):
        # 生产者逻辑:只需要在队列中put问题
        import random
        while True:
            time.sleep(1)
            x = random.randint(1, 100)
            self.queue.put(x)
            print(f'生产者生产了数据{x}')

生产者和消费者模型-线程

import threading
import queue
import time


q = queue.Queue(4)  #生成一个队列

#生产者
class Producer(threading.Thread):
    def __init__(self,queue):
        super().__init__()
        self.queue = queue

    def run(self):
        # 生产者逻辑:只需要在队列中put问题
        import random
        while True:
            time.sleep(1)
            x = random.randint(1,100)
            self.queue.put(x)
            print(f'生产者生产了数据{x}')

#消费者
class Consumer(threading.Thread):

    def __init__(self, queue):
        super().__init__()
        self.queue = queue

    def run(self):
        # 消费者逻辑，只需要把队列中的问题get出来消费
        import random
        while True:
            time.sleep(1)

            data = self.queue.get()
            print(f'消费者消费了数据{data}')

pr = Producer(q)
cu = Consumer(q)
pr.start()
time.sleep(1)
cu.start()