Python-线程(2)

目录

• GIL全局解释器锁
  • GIL 与 Lock
• 多进程 VS 多线程
• 死锁现象
• 递归锁
• 信号量
  • Semaphore
• 线程队列

GIL全局解释器锁

在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势

首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。>有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

GIL 本质上就是一把互斥锁，将并发运行编程串行，以此来控制同一时间内共享的数据只能被一个任务锁修改，进而保证数据的安全

可以肯定的是，保护数据的安全，就应该加锁

'''
验证全局解释器锁
'''
import time
from threading import Thread,current_thread

n = 100

def task():
    global n
    n2 = n
    # 全局解释器锁碰到 IO阻塞就切换cpu执行并解锁
    time.sleep(1)
    n = n2 - 1
    print(n,current_thread().name)

for line in range(100):
    t = Thread(target=task)
    t.start()

GIL 与 Lock

为什么有了解释器的锁来保证同一时间只能有一个线程来执行，为什么还需要有线程的lock锁？

首先，我们要达成共识，锁的目的就是为了保护数据，同一时间只能有一个线程来修改共享的数据

然后，我们就可以得到结论：保护不同的数据我们需要加不同的锁

那么 GIL 与Lock是两把锁，保护的数据不一样，GIL是解释器里的，保护的是解释器级别的数据，比如垃圾回收的数据，Lock是保护用户自己开发的应用程序的数据，很明显GIL自己不负责这件事，只能用户自定义加锁处理，即Lock

当我们在没有IO的程序里面（纯计算）不加锁不会存在锁的错乱问题，因为GIL限制了同一时刻只能让一个线程执行，所以不用加锁

当我们在IO密集的程序里面，不加锁会导致数据安全问题，因为程序遇到IO cpu会切断使用权，让另一个线程执行，那么这时候另一个线程拿到的数据还是之前的一份，不是最新的，导致所有线程修改数据不是正确的，引起数据安全问题，所以这个时候加上线程锁来保证这个数据安全

多进程 VS 多线程

站在两个角度看问题

计算密集型：

​ 单核：

​ 开启进程：消耗资源大

​ 开启线程：消耗资源小于进程

​ 多核：

​ 开启进程：并行执行，效率高

​ 开启线程：并发执行，效率低

IO密集型：

​ 单核：

​ 开启进程：消耗资源大

​ 开启线程：消耗资源小于进程

​ 多核：

​ 开启进程：并行执行，效率小于多线程，因为遇到IO会立即切换CPU的执行权限

​ 开启线程：并发执行，效率高于多进程

# coding=utf-8

from multiprocessing import Process
from threading import Thread
import os
import time

# 计算密集型
def work1():
    num = 0
    for i in range(40000000):
        num += 1

# IO密集型
def work2():
    time.sleep(1)

if __name__ == '__main__':
    # 测试计算密集型
    start_time = time.time()
    ls = []
    for i in range(10):
        # 测试多进程
        p = Process(target=work1)       # 程序执行时间为7.479427814483643
        # 测试多线程
        # p = Thread(target=work1)       # 程序执行时间为28.56563377380371
        ls.append(p)
        p.start()
    for l in ls:
        l.join()

    end_time = time.time()
    print(f"程序执行时间为{end_time - start_time}")

    # 测试计算密集型结论：
    # 在计算较小数据时候使用多线程效率高
    # 在计算较大数据时候使用多进程效率高

    # 测试IO密集型
    start_time = time.time()
    ls = []
    for i in range(10):
        # 测试多进程
        # p = Process(target=work2)       # 程序执行时间为2.749157190322876
        # 测试多线程
        p = Thread(target=work2)  # 程序执行时间为1.0130579471588135
        ls.append(p)
        p.start()
    for l in ls:
        l.join()

    end_time = time.time()
    print(f"程序执行时间为{end_time - start_time}")

    # 测试IO密集型结论：
    # 使用多线程效率要比使用多进程效率高

计算密集型情况下：

​ 在计算较小数据时候使用多线程效率高

​ 在计算较大数据时候使用多进程效率高

IO密集型情况下：

​ 使用多线程效率要比使用多进程效率高

高效执行程序：

​ 使用多线程和多进程

这里打个比方：

一个工人相当于cpu，工厂原材料就相当于线程。

此时计算相当于工人在干活，I/O阻塞相当于为工人干活提供所需原材料的过程，工人干活的过程中如果没有原材料了，则工人干活的过程需要停止，直到等待原材料的到来。

如果你的工厂干的大多数任务都要有准备原材料的过程（I/O密集型），那么你有再多的工人，意义也不大，还不如一个人，在等材料的过程中让工人去干别的活，

反过来讲，如果你的工厂原材料都齐全，那当然是工人越多，效率越高

结论：

对计算机来说：CPU越多越好，但是对于IO来说，再多的CPU也没用

对于程序来说：随着CPU的增多执行效率肯定会有所提高（不管提高多大，总会有所提高）

假设我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：

方案一：开启四个进程

方案二：一个进程下，开启四个线程

结果：

​ 单核：

​ 若四个任务是计算密集型，方案一增加了创建进程时间，方案二远小于方案一，方案二胜

​ 若四个任务是I/O密集型，方案一也增加了创建进程时间，且进程切换速度还不如线程，所以方 案二又胜

​ 多核：

​ 若四个任务是计算密集型，多核 开多个进程一起计算是并行计算，在线程中执行用不上多核， 那么方案一效率高，方案一胜

​ 若四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜

结论：

​ 现在的计算机基本上都是多核，python对于计算密集型的程序来说，开多线程的效率并不能带来多 大性能的提升，甚至还不如串行，但是对于I/O密集型的程序来说，开多线程效率就明显提升

多线程用于I/O密集型：例如Socket、爬虫、Web

多进程用于计算密集型，如金融分析，数据分析

死锁现象

# coding=utf-8

from threading import Lock,Thread,current_thread
import time

mutex_a = Lock()
mutex_b = Lock()

class MyThread(Thread):
    # 线程执行任务
    def run(self):
        self.work1()
        self.work2()

    def work1(self):
        mutex_a.acquire()
        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 work2(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 i in range(2):
    t = MyThread()
    t.start()

Thread-1 抢到了锁a
Thread-1 抢到了锁b
Thread-1 释放了锁b
Thread-1 释放了锁a
Thread-1 抢到了锁b
Thread-2 抢到了锁a
.....卡主了

开启两个线程之后，每个线程会抢cpu执行，

第一个线程抢到了，执行work1，抢到锁a、b，释放a、b

再回来执行work2，抢到锁b，碰到有IO阻塞，切换线程执行

到第二个线程，可以抢到锁a，但是锁还在第一个线程手里拿着

锁b么有被释放，线程二拿不到锁b，于是卡主了

递归锁

解决死锁问题，需要用到递归锁

RLock：只有一把钥匙，可以提供多个线程去使用，每次使用会计数+1，只有计数为0 的时候 才能真正释放让另一个线程使用

可以理解为遇到IO操作之后，如果身上有这个递归锁，必须先把这个递归锁解开之后然后你再去做其他事情。

# coding=utf-8

from threading import Lock,Thread,current_thread,RLock
import time

# mutex_a = Lock()
# mutex_b = Lock()
mutex_a = mutex_b = RLock()

class MyThread(Thread):
    # 线程执行任务
    def run(self):
        self.work1()
        self.work2()

    def work1(self):
        mutex_a.acquire()
        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 work2(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 i in range(2):
    t = MyThread()
    t.start()

Thread-1 抢到了锁a
Thread-1 抢到了锁b
Thread-1 释放了锁b
Thread-1 释放了锁a
Thread-1 抢到了锁b

Thread-1 抢到了锁a
Thread-1 释放了锁a
Thread-1 释放了锁b
Thread-2 抢到了锁a
Thread-2 抢到了锁b
Thread-2 释放了锁b
Thread-2 释放了锁a
Thread-2 抢到了锁b

Thread-2 抢到了锁a
Thread-2 释放了锁a
Thread-2 释放了锁b

信号量

Semaphore

互斥锁：只有一把锁，只能一个人去使用

信号量：可以自定义锁的数量，提供多个人使用

# coding=utf-8

from threading import Semaphore,Lock
from threading import current_thread
from threading import Thread
import time

# 信号量：提供5个锁
sm = Semaphore(5)

# 互斥锁：提供一个锁
mutex = Lock()

def task():
    sm.acquire()
    print(f"子线程{current_thread().name}")
    time.sleep(1)
    sm.release()

if __name__ == '__main__':
    for i in range(10):
        t = Thread(target=task)
        t.start()

# 五个五个执行
子线程Thread-1
子线程Thread-2
子线程Thread-3
子线程Thread-4
子线程Thread-5

子线程Thread-6
子线程Thread-7
子线程Thread-8
子线程Thread-9
子线程Thread-10

线程队列

FIFO：先进先出

LIFO：后进先出

优先级队列：根据参数中的数字字母排序，排在前面的优先级越高，优先取出

# coding=utf-8

import queue
from multiprocessing import Queue

# FIFO队列：先进先出
q = queue.Queue()
q.put(4)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
# 4
# 2

# LIFO队列：后进先出
q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
# 3
# 2

# 优先级队列
q = queue.PriorityQueue()
q.put(3)
q.put(2)
q.put(11)
print(q.get())
# 2