并发编程_线程

进程间通信

 　　之前说 进程就是一块内存空间 且 进程与进程之间是相互 间隔的 无法直接的交互 但是 可以通过 队列来实现

队列:先进先出

堆栈:先进后出

方法 from multiprocessing import Queue 导入模块

q = Queue()   生成 队列   括号内可以传参 表示 这个队列的最大 储存数 

q.put(xxxx)   往 对列内放入 

q.full()   判断对列是否满了  (如果当前对列满了的话 在放入数据 不会报错 会在原地等待 直到队列中的数据被取中 他属于 阻塞态)

q. get()    单队列中取完没有值了 再次获取 程序就会堵塞 原地等待 直到有值 加入才会 继续

q.empty()  判断对列中的数据是否被取完

q.get_nowait() 也是 取值 但是取完他不等待 直接报错

ps: full get_nowait empty 都不适格 多进程的情况

 

进程间通信IPC机制: 

 生产者消费者模型

导入模块  multiprocessing import JoinableQueue  (能够被等待的队列)

q = JoinableQueue() 生成队列

q.join()  等待队列中的数据全部取出 检测 队列中有多少个数据 例如 加一个 就 加一 处理完成 减 一 当 他执行完 说明没有数据了 

q.task_done() 告诉队列 你已经 从队列里取出一个数据 并且处理完毕

代码如下

from multiprocessing import Process, JoinableQueue
import time
import random

# 生产者
def make(name,food, q):
    for i in range(10):
        time.sleep(random.random())
        res = f"{name}做了第{i+1}个{food}"
        print(res)
        q.put(res)

# 消费者
def eat(name,q):
    while True:
        res = q.get()
        if res == None:break
        time.sleep(random.random())
        print(f"{name}吃了{res}")
        q.task_done()

if __name__ == '__main__':
    q = JoinableQueue()
    p = Process(target=make, args=('egon','包子',q))
    p1 = Process(target=make, args=('tank','生蚝',q))
    c = Process(target=eat, args=('json',q))
    # p.daemon = True
    p1.start()
    p.start()
    c.daemon = True
    c.start()
    p1.join()
    p.join()
    q.join()

线程

什么是线程
    进程线程其实都是虚拟单位,都是用来帮助我们形象的描述某种事物

    进程:资源单位
    线程:执行单位
        将内存比如成工厂
        那么进程就相当于是工厂里面的车间
        而你的线程就相当于是车间里面的流水线
    ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中
    提供代码运行所需要的资源

为什么要有线程
    开进程
        1.申请内存空间  耗资源
        2."拷贝代码"    耗资源
       
    开线程
        一个进程内可以起多个线程,并且线程与线程之间数据是共享的
    ps:开启线程的开销要远远小于开启进程的开销

创建线程的两种方式

 

线程对象及其他方法

t.start()  # 告诉操作系统开辟一个线程  线程的开销远远小于进程

t1.join()  # 主线程等待子线程运行完毕
.......

守护线程

主线程的结束也就意味着进程的结束
主线程必须等待其他非守护线程的结束才能结束
(意味子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)

线程之间可以直接通信

from threading import Thread

money = 666

def task():
    global money
    money = 999

t = Thread(target=task)
t.start()
t.join()
print(money)

互斥锁

from threading import Thread,Lock
import time


n = 100

def task(mutex):
    global  n
    mutex.acquire()
    tmp = n
    time.sleep(0.1)
    n = tmp - 1
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(n)