并发通信和消费者生产模型

一：进程通信

        进程之间有通信隔离，解决进程之间通信隔离方法：开辟一个公共空间

     

import multiprocessing #导入多进程模块

a = 10
# 开辟一块缓冲区
mm = multiprocessing.Manager()
# 在缓冲区开辟列表空间
mli = mm.list()
# 在缓冲区开辟字典空间
mdi = mm.dict()
# mli[0]=10
mli.append(10)
# 列表空间在修改里面数据的时候 可以当做列表使用 添加数据只能使用append，extend，insert这几个方法添加
mdi.update({'a': 1, 'b': 2})
# 添加数据和列表空间一样，不能直接添加，要调用方法

    

# def f3():
#     for i in range(5):
#         mli[0] += 1
#     print('f', mli[0])
#
#
# m3 = multiprocessing.Process(target=f3)
# m3.start()
#
# m3.join()
#
# print('main', mli[0])

def f4():
    mdi.update({'c':3})
    print('f4',mdi)

m4 = multiprocessing.Process(target=f4)
m4.start()
m4.join()
print('main',mdi)

   二：多线程资源抢占

import threading #导入多线程模块

a = 10
# 实例化一个锁
lock = threading.Lock()

def f():
    # global a
    # lock.acquire() #加锁 作用就是确保被锁住的代码，能从头到尾由一个线程执行
    # for i in range(1000000):
    #     a += 1
    #     a -= 1
    # lock.release()#解锁
    # print(a)

    # lock可以通过with触发，自动加解锁
    global a
    with lock:
        for i in range(1000000):
            a += 1
            a -= 1
        print(a)


t1 = threading.Thread(target=f)
t1.start()

t2 = threading.Thread(target=f)
t2.start()

t1.join()
t2.join()
print('main',a)

三：队列

import queue

# 创建一个队列 括号写入队列可容纳的最大数
q = queue.Queue(5)

for i in range(6):
    q.put(i) #在队列已经满了的情况下 如果还要put 就会产生阻塞

for i in range(5):
    print(q.get(i))#在队列已经空了的情况下，还要get 就会产生阻塞

  四：消费者生产模型

import threading
import queue
import time
import random

# 消费者类
class Consumer(threading.Thread):
    def __init__(self,q):
        super().__init__()
        self.q = q

    def run(self):
        while True:
            data = self.q.get()
            time.sleep(1)
            print(data,'已处理')

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

    def run(self):
        while True:
            data = random.randint(0,100)
            self.q.put()
            time.sleep(1)
            print(data,'已生成')

q = queue.Queue(10)

pro = Producer(q)
pro.start()

con = Consumer(q)
con.start()