(day30)GIL + 线程相关知识点

目录

• 昨日内容
  • 进程互斥锁
  • 队列
  • 进程间通信
  • 生产者与消费者模型
  • 线程
    • 什么是线程
    • 为什么使用线程
  • 创建线程的两种方式
  • 线程对象的属性
  • 线程互斥锁
• 今日内容
  • GIL全局解释器锁
  • 多线程的作用
    • 计算密集型
    • IO密集型
  • 死锁
  • 递归锁（RLock）
  • 信号量（semaphore）
  • 线程队列
    • FIFO队列（Queue()）
    • LIFO队列（lifoQueue()）
    • 优先级队列（PriorityQueue()）

昨日内容

进程互斥锁

让并发变成串行,牺牲了效率,包哦挣了数据安全

mutex = Lock()
# 加锁
mutex.acquire()
# 释放锁
mutex.release()

队列

相当于在内存中开辟了一个队列空间,可以存放一堆数据，遵循“先进先出”，管道（阻塞）+锁

q = Queue()
q.put() # 添加数据，若队列满了，卡住
q.put_nowait()  # 若队列满了，报错
q.get() # 获取数据，若队列为空，卡住
q.get_nowait()  # ，若队列为空，报错
q.empty()  # 判断队列是否为空
q.full()  # 判断队列是否满了

进程间通信

进程间数据不共享，可以通过队列实现通信

生产者与消费者模型

生产者：生产数据的

消费者：使用数据的

目的：通过队列来实现该模型，解决供需不平衡问题

线程

什么是线程

进程：执行单位

线程：执行单位

注意：只要开启一个进程就会有一个线程，会在进程结束时，一并销毁

为什么使用线程

节省内存资源

• 开启线程
  1. 开辟一个新的内存空间
  2. 会自带一个主线程
• 开启线程
  1. 一个进程可以开启多个线程
  2. 开启线程的资源远远小于进程

创建线程的两种方式

# 创建方式1
from threading import Thread
def task():
    pass

t = Thread(target = task)
t.start()

# 创建方式2
class MyThread(Thread):
    def run():
        pass

t= MyThread()
t.start()

线程对象的属性

current_thread().name  # 获取当前线程名
enumerate()  # 获取当前所有线程对象
activeCount()  # 获取当前执行线程个数
is_alive()  # 判断线程是否存活

线程互斥锁

from threading import Thread
mutex = Lock()
mutex.acquire()
# 被锁线程
mutex.release(

今日内容

GIL全局解释器锁

基于Cpython来研究GIL

1. GIL本质上是一个互斥锁
2. 阻止同一个进程下多个线程同时执行，即单个进程下的多个线程不能并行，只能并发
3. GIL的存在是为了保证线程安全（垃圾回收机制）

注意：多个线程过来执行，一旦遇到IO操作，会立马释放GIL全局解释器锁，

from threading import Thread
import time

number = 100

def task():
    global number
    number2 = number
    time.sleep(1)
    nunmer = number2 -1

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

多线程的作用

计算密集型

单核情况下，优先使用多线程

多核情况下，优先使用多进程

总结：现在大多数电脑都是多核，因此计算密集型使用多进程

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

def work():
    res = 0
    for i in range(100000000):
        res*=i

if __name__ == '__main__':
    l = []
    print(os.cpu_count())
    start = time.time()
    for i in range(4):
        p = Process(target = work)
        # p = Thread(target = work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop = time.time()
    print(f'{stop-start}')

IO密集型

单核情况下，优先使用多线程

多核情况下，优先使用多线程

总结：IO密集型使用多线程

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

def work():
    time.sleep(2)
    print('>>>>>>>>>')

if __name__ == '__main__':
    l = []
    print(os.cpu_count())
    start = time.time()
    for i in range(40):
        # p = Process(target = work)
        p = Thread(target = work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop = time.time()
    print(f'{stop-start}')

在高效执行多个IO密集型的程序：使用多进程+多线程

死锁

死锁现象：两个或两个以上的进程或线程在执行过程中因争夺资源而造成一种互相等待的现象，称为系统处于死锁状态，或者产生了死锁。

import time
from threading import Lock,Thread

mutex1 = Lock()
mutex2 = Lock()

def task():
    work1()
    work2()

def work1():
    mutex1.acquire()
    print('拿到锁1')
    mutex2.acquire()
    print('拿到锁2')
    mutex2.release()
    print('解开锁1')
    mutex1.release()
    print('解开锁2')

def work2():
    mutex2.acquire()
    time.sleep(1)
    mutex1.acquire()
    print('拿到锁2')
    mutex1.release()
    print('解开锁1')
    mutex2.release()
    print('解开锁2')

for i in range(10):
    t = Thread(target=task)
    t.start()

递归锁（RLock）

内部维护者一个Lock和counter变量，counter记录acquire的次数，release可以使counter次数减1，只有counter为0时，才能被使用

用于解决死锁问题，相当于连环锁，要么不用，要么一起拿过去

import time
from threading import RLock,Thread

mutex1 = mutex2= RLock()

def task():
    work1()
    work2()

def work1():
    mutex1.acquire()
    print('拿到锁1')
    mutex2.acquire()
    print('拿到锁2')
    mutex2.release()
    print('解开锁1')
    mutex1.release()
    print('解开锁2')

def work2():
    mutex2.acquire()
    time.sleep(1)
    mutex1.acquire()
    print('拿到锁2')
    mutex1.release()
    print('解开锁1')
    mutex2.release()
    print('解开锁2')

for i in range(10):
    t = Thread(target=task)
    t.start()

信号量（semaphore）

信号量：内置计数器，每当调用acquire内置计数器-1，调用release内置计数器+1，计数器不能小于0，计数器为0时，acquire会阻塞线程直到其他线程调用release

相当于锁店

import time
from threading import Lock,Thread,Semaphore

sm = Semaphore(10)

def task():
    work1()
    work2()

def work1():
    sm.acquire()
    print('拿到锁1')
    sm.acquire()
    print('拿到锁2')
    sm.release()
    print('解开锁1')
    sm.release()
    print('解开锁2')

def work2():
    sm.acquire()
    time.sleep(1)
    sm.acquire()
    print('拿到锁2')
    sm.release()
    print('解开锁1')
    sm.release()
    print('解开锁2')

for i in range(10):
    t = Thread(target=task)
    t.start()

线程队列

FIFO队列（Queue()）

先进先出

import queue

q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''

LIFO队列（lifoQueue()）

后进后出

import queue

q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''

优先级队列（PriorityQueue()）

1. 首先根据第一个参数判断ascii表的数值大小

2. 判断第二个参数中的汉字顺序

3. 再判断第二参数中数字--> 字符串数字 ---> 中文

4. 以此类推

import queue

q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))

print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''