第十五章、Python多线程之信号量和GIL

目录

• 第十五章、Python多线程之信号量和GIL
  • 1. 信号量(Semaphore)
  • 2. GIL
    • 说明：

第十五章、Python多线程之信号量和GIL

1. 信号量(Semaphore)

信号量用来控制线程并发数的，Semaphore管理一个内置的计数 器，每当调用acquire()时-1，调用release()时+1。计数器不能小于0，当计数器为 0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release()。其实就是控制最多几个线程可以操作同享资源。

import threading
import time

semaphore = threading.Semaphore(5)

def func():
    if semaphore.acquire():
        print (threading.currentThread().getName() + '获取共享资源')
        time.sleep(2)
        semaphore.release()

for i in range(10)
  t1 = threading.Thread(target=func)
  t1.start()
--------------------------------------------------
Thread-1获取共享资源
Thread-2获取共享资源
Thread-3获取共享资源
Thread-4获取共享资源
Thread-5获取共享资源

Thread-6获取共享资源
Thread-8获取共享资源
Thread-7获取共享资源
Thread-9获取共享资源
Thread-10获取共享资源

上面一个简单的例子就是创建10个线程，让每次只让5个线程去执行func函数。

结果：5个线程一批一批的执行打印,中间停格2s

2. GIL

含义：全局解释器锁 。

作用：无论你启多少个线程，你有多少个cpu, Python在执行的时候只会的在同一时刻只允许一个线程（线程之间有竞争）拿到GIL在一个cpu上运行，当线程遇到IO等待或到达者轮询时间的时候，cpu会做切换，把cpu的时间片让给其他线程执行，cpu切换需要消耗时间和资源，所以计算密集型的功能（比如加减乘除）不适合多线程，因为cpu线程切换太多，IO密集型比较适合多线程。

任务：

• IO密集型（各个线程都会都各种的等待，如果有等待，线程切换是比较适合的），也可以采用可以用多进程+协程

• 计算密集型（线程在计算时没有等待，这时候去切换，就是无用的切换），python不太适合开发这类功能

  ​ 我们前面举得例子里面模拟了sleep操作，其实就是相当于遇到IO，这种场景用多线程是可以增加性能的，但是如果我们用多线程来计算数据的计算，性能反而会降低。

证明一下：

from threading import Thread
from multiprocessing import Process
import time

#计算密集型
def work1():
    res=0
    for i in range(100000000): #1+8个0
        res*=i

if __name__ == '__main__':
    t_list = []
    start = time.time()
    for i in range(4):
        # t = Thread(target=work1)
        t = Process(target=work1)
        t_list.append(t)
        t.start()
    for t in t_list:
        t.join()
    end = time.time()
    # print('多线程',end-start) # 多线程 15.413789510726929
    print('多进程',end-start) # 多进程 4.711405515670776

from threading import Thread
from multiprocessing import Process
import time
# io密集型
def work1():
    x = 1+1
    time.sleep(5)

if __name__ == '__main__':
    t_list = []
    start = time.time()
    for i in range(4):
        t = Thread(target=work1)
        # t = Process(target=work1)
        t_list.append(t)
        t.start()
    for t in t_list:
        t.join()
    end = time.time()
    print('多线程',end-start) #  多线程 5.002625942230225
    # print('多进程',end-start) # 多进程 5.660863399505615

说明：

在Cpython解释器中有一把GIL锁(全局解释器锁)，GIl锁本质是一把互斥锁。
导致了同一个进程下,同一时间只能运行一个线程,无法利用多核优势.
同一个进程下多个线程只能实现并发不能实现并行.
为什么要有GIL?
因为cpython自带的垃圾回收机制不是线程安全的,所以要有GIL锁.
导致了同一个进程下,同一时间只能运行一个线程,无法利用多核优势.
分析：我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：
方案一：开启四个进程
方案二：一个进程下，开启四个线程
计算密集型 推荐使用多进程
 每个都要计算10s
 多线程
 在同一时刻只有一个线程会被执行,也就意味着每个10s都不能省,分开每个都要计算10s,共40.ns
 多进程
 可以并行的执行多个线程,10s+开启进程的时间