• GIL全局解释器锁


    GIL全局解释器

    1.GIL全局解释器锁:
    1.GIL是Cpython特有的。
    2.GIL本质上是一个互斥锁.
    3.GIL的为了阻止同一个进程内多个线程同时执行(并行)
    - 单个进程下的多个线程无法实现并行,但能实现并发
    4.这把锁主要是因为CPython的内存管理不是 "线程安全" 的.
    - 保证线程在执行任务时不会被垃圾回收机制回收。

    2.GIL存在的目的:
    GIL的存在就是为了保证线程安全的.

    注意: 多个线程过来执行,一旦遇到IO操作,就会立马释放GIL解释器锁,交给下一个先进来的线程.

    import time
    from threading import Thread, current_thread
    from threading import Lock
    
    number = 100
    
    mutex = Lock()
    
    def task():
        global number
        number2 = number
        time.sleep(1)
        number = number2 - 1
        print(number, current_thread().name)
    
    
    for line in range(4):
        t = Thread(target=task)
        t.start()
    
    打印结果:
    99 Thread-2
    99 Thread-3
    99 Thread-1
    99 Thread-4

    验证多线程的作用

    多线程的作用:
    站在两个角度去看问题:

    - 四个任务, 计算密集型, 每个任务需要10s:
    单核:
    - 开启进程
    消耗资源过大
    - 4个进程: 40s

    - 开启线程
    消耗资源远小于进程
    - 4个线程: 40s

    多核:
    - 开启进程
    并行执行,效率比较高
    - 4个进程: 10s

    - 开启线程
    并发执行,执行效率低.
    - 4个线程: 40s



    - 四个任务, IO密集型, 每个任务需要10s:
    单核:
    - 开启进程
    消耗资源过大
    - 4个进程: 40s

    - 开启线程
    消耗资源远小于进程
    - 4个线程: 40s

    多核:
    - 开启进程
    并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限
    - 4个进程: 40s + 开启进程消耗的额外时间

    - 开启线程
    并发执行,执行效率高于多进程

    - 4个线程: 40s
    所以:
    在计算密集型的情况下:
    使用多进程

    在IO密集型的情况下:
    使用多线程

    高效执行多个进程,内多个IO密集型的程序:
    使用 多进程 + 多线程
    
    
    from threading import Thread
    from multiprocessing import Process
    import os
    import time
    
    
    # 计算密集型
    def work1():
        number = 0
        for line in range(100000000):
            number += 1
    
    
    # IO密集型
    def work2():
        time.sleep(1)
    
    
    if __name__ == '__main__':
    
        # 测试计算密集型
        # print(os.cpu_count())  # 6
        # # 开始时间
        # start_time = time.time()
        # list1 = []
        # for line in range(6):
        #     p = Process(target=work1)  # 程序执行时间5.300818920135498
        #     # p = Thread(target=work1)  # 程序执行时间24.000795602798462
        #
        #     list1.append(p)
        #     p.start()
    
        # IO密集型
        print(os.cpu_count())  # 6
        # 开始时间
        start_time = time.time()
        list1 = []
        for line in range(40):
            # p = Process(target=work2)  # 程序执行时间4.445072174072266
            p = Thread(target=work2)  # 程序执行时间1.009237289428711
    
            list1.append(p)
            p.start()
    
        for p in list1:
            p.join()
        end_time = time.time()
    
        print(f'程序执行时间{end_time - start_time}')
    
    

    死锁现象

    from threading import Lock, Thread, current_thread
    import time
    
    mutex_a = Lock()
    mutex_b = Lock()
    #
    # print(id(mutex_a))
    # print(id(mutex_b))
    
    
    class MyThread(Thread):
    
        # 线程执行任务
        def run(self):
            self.func1()
            self.func2()
    
        def func1(self):
            mutex_a.acquire()
            # print(f'用户{current_thread().name}抢到锁a')
            print(f'用户{self.name}抢到锁a')
            mutex_b.acquire()
            print(f'用户{self.name}抢到锁b')
            mutex_b.release()
            print(f'用户{self.name}释放锁b')
            mutex_a.release()
            print(f'用户{self.name}释放锁a')
    
        def func2(self):
            mutex_b.acquire()
            print(f'用户{self.name}抢到锁b')
            # IO操作
            time.sleep(1)
    
            mutex_a.acquire()
            print(f'用户{self.name}抢到锁a')
            mutex_a.release()
            print(f'用户{self.name}释放锁a')
            mutex_b.release()
            print(f'用户{self.name}释放锁b')
    
    
    for line in range(10):
        t = MyThread()
        t.start()

    递归锁

    递归锁(了解):
    用于解决死锁问题.

    RLock: 比喻成万能钥匙,可以提供给多个线程去使用.
    但是第一个使用的时候,会对该锁做一个引用计数.
    只有引用计数为0, 才能真正释放让另一个线程去使用
    from threading import RLock, Thread, Lock
    import time
    
    mutex_a = mutex_b = RLock()
    
    
    class MyThread(Thread):
    
        # 线程执行任务
        def run(self):
            self.func1()
            self.func2()
    
        def func1(self):
            mutex_a.acquire()
            # print(f'用户{current_thread().name}抢到锁a')
            print(f'用户{self.name}抢到锁a')
            mutex_b.acquire()
            print(f'用户{self.name}抢到锁b')
            mutex_b.release()
            print(f'用户{self.name}释放锁b')
            mutex_a.release()
            print(f'用户{self.name}释放锁a')
    
        def func2(self):
            mutex_b.acquire()
            print(f'用户{self.name}抢到锁b')
            # IO操作
            time.sleep(0.1)
            mutex_a.acquire()
            print(f'用户{self.name}抢到锁a')
            mutex_a.release()
            print(f'用户{self.name}释放锁a')
            mutex_b.release()
            print(f'用户{self.name}释放锁b')
    
    
    for line in range(10):
        t = MyThread()
        t.start()

    信号量

    from threading import Semaphore, Lock
    from threading import current_thread
    from threading import Thread
    import time
    
    sm = Semaphore(5)  #  每个锁里面一次性运行5个
    # mutex = Lock()  # 每个锁里面一次运行一个
    
    
    def task():
        # mutex.acquire()
        sm.acquire()
        print(f'{current_thread().name}执行任务')
        time.sleep(1)
        sm.release()
        # mutex.release()
    
    
    for line in range(20):
        t = Thread(target=task)
        t.start()

     线程队列

    线程Q(了解级别1): 线程队列  面试会问: FIFO

    - FIFO队列: 先进先出
    - LIFO队列: 后进先出
    - 优先级队列: 根据参数内,数字的大小进行分级,数字值越小,优先级越高
    import queue
    
    #通的线程队列: 先进先出
    q = queue.Queue()
    q.put(1)
    q.put(2)
    q.put(3)
    print(q.get())  # 1
    
    
    #LIFO队列: 后进先出
    q = queue.LifoQueue()
    q.put(1)
    q.put(2)
    q.put(3)
    print(q.get())  # 3
    import queue
    # 优先级队列
    q = queue.PriorityQueue()  # 超级了解
    # 若参数中传的是元组,会以元组中第一个数字参数为准
    q.put(('a优', '', '娃娃头', 4))  # a==97
    q.put(('a先', '', '娃娃头', 3))  # a==98
    q.put(('a级', '', '娃娃头', 2))  # a==99
    '''
    1.首先根据第一个参数判断ascii表的数值大小
    2.判断第个参数中的汉字顺序.
    3.再判断第二参数中数字--> 字符串数字 ---> 中文
    4.以此类推
    '''
    print(q.get())  #('a优', '先', '娃娃头', 4)
    
    
  • 相关阅读:
    未完存储过程MySQL
    看山不是山——我们眼中的世界并不可观
    常用Linux命令
    表格行列的删除
    RFID会议签到系统总结(二十一)――服务端的通讯
    FastReport的一些另类用法
    RFID会议签到系统总结(二十二)――系统中的模式
    单元格的计算
    表格行列的移动
    RFID会议签到系统总结(十九)――单数据窗体
  • 原文地址:https://www.cnblogs.com/fjn839199790/p/11728396.html
Copyright © 2020-2023  润新知