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)
并发编程 2
来源: http://www.bubuko.com/infodetail-3256108.html