• 并发编程_线程


    进程间通信

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

    队列:先进先出

    堆栈:先进后出

    方法 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)
     
    趁自己还没死 多折腾折腾
  • 相关阅读:
    A1061 Dating [字符串比较]
    A1058 A+B in Hogwarts [进制转换]
    A1027 Colors in Mars[简单模拟--进制转换]
    A1031 Hello World for U[图形输出]
    刷PAT的一些思考—Day 1
    A1009 Product of Polynomials[简单模拟--多项式相乘]
    A1002 A+B for Polynomials[简单模拟--多项式相加]
    A1046 Shortest Distance [简单模拟--卡算法复杂度]
    1009 说反话
    usb之配置描述符
  • 原文地址:https://www.cnblogs.com/lddragon/p/11341477.html
Copyright © 2020-2023  润新知