互斥锁 线程理论 GIL全局解释器锁 死锁现象 信号量 event事件 进程池与线程池 协程实现并发

目录

• 互斥锁
  • multiprocessing Lock类
  • 锁的种类
• 线程理论
  • 进程和线程对比
• 开线程的两种方式（类似进程）
  • 方式1 使用Thread()创建线程对象
  • 方式2 重写Thread类run方法
  • 创建1000个进程 vs 创建1000个线程
  • 线程的诸多特性
    • 验证线程数据共享
    • 查看线程名字 current_thread().name
    • 验证线程在同一个进程 os.getpid()
    • 进程下存活的线程数 active_count()
    • 补充
• GIL全局解释器锁
  • 流程推导（重要）
  • 多个cpu情况
  • 验证GIL的存在
  • 阻塞验证
  • GIL与普通互斥锁
  • python多线程是否有用？
• 死锁现象
• 信号量
• event事件
• 进程池与线程池
  • 线程池
    • 基本使用
    • 固定的线程
  • 查看源码
  • 进程池
    • task传参(线程池也这样传)
    • 回调函数
• 协程
  • monkey模块
  • 协程实现并发

互斥锁

作用：专门把并发变成串行

锁会造成程序执行效率的下降 但是保证了数据的安全

注意事项：

1. 互斥锁不能轻易使用 容易造成死锁现象
2. 建议只在处理数据的地方加锁 不能什么地方都加

抢锁与放锁：

抢锁：宿舍抢厕所 抢到钥匙就锁门 别人在外面等着

放锁：开门之后 其他人再抢

两把锁对应两个厕所

示例：

12306抢票>>>查票可以一次性给所有人看 买票（想要修改数据时）必须排队！这里就是一个抢锁的过程。在规定的时间不付钱 买票的资格就没有了（支付时间15min）

multiprocessing Lock类

from multiprocessing import Process, Lock
import time
import json
import random

# data文件存放一个字典：{'ticket_num': 1}
ticket_dict = {'ticket_num': 1}
with open('data.json', 'w', encoding='utf8') as f:
    json.dump(ticket_dict, f)

def search(name):
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print('%s查看票 目前剩余:%s' % (name, data.get('ticket_num')))

def buy(name):
    # 先查询票数
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1, 3))
    # 买票
    if data.get('ticket_num') > 0:
        with open(r'data.json', 'w', encoding='utf8') as f:
            data['ticket_num'] -= 1
            json.dump(data, f)
        print('%s 买票成功' % name)
    else:
        print('%s 买票失败 非常可怜 没车回去了!!!' % name)

def run(name, mutex):
    search(name)
    mutex.acquire()  # 抢锁
    buy(name)
    mutex.release()  # 释放锁

if __name__ == '__main__':
    mutex = Lock()  # 在主进程产生一把锁  让多个子进程去抢
    for i in range(10):
        p = Process(target=run, args=('用户%s号' % i, mutex))  # 用process起进程的时候 进程是没有确定的先后顺序的 也就是随机的 异步操作
        p.start()                                             # 不一定说你是进程1 你就能先查看到票 再先抢到锁

使用multiprocessing的Lock类来解决火车票抢票问题：(将买票环节变成串行 所有进程抢锁)

锁的种类

# 重申：锁会造成程序执行效率的下降 但是保证了数据的安全

1.行锁：针对行数据加锁 同一时间只能一个人操作
对第一行加锁 第一行就只能一个人操作 其他人不能操作

2.表锁：针对表数据加锁 同一时间只能一个人操作
锁的核心是为了保证数据的安全 并发变串行保障数据的安全

ps:几乎不会自己操作锁 理解原理即可

线程理论

进程
	进程其实是资源单位 表示一块内存空间
线程
	线程才是执行单位 是真正干活的人

隐喻：进程相当于车间（一个个空间）线程相当于车间里的流水线（真正干活的）

进程里没有线程就是一个空白的空间！
所以说>>>: '''一个进程中至少有一个线程！'''
进程去内存中占位置，线程在进程中干活 进程用来'圈地'

进程和线程对比

开进程：
	1.开销大（申请内存空间）
	2.拷贝代码（windows下导模块）
	3.不同进程下无法数据共享（内存空间不同）
开线程：
	1.开销小（无需申请内存空间，直接使用进程的内存空间）
	2.同一个进程中的多个线程数据共享（在一个车间内）（在同一片内存空间）

开线程的两种方式（类似进程）

方式1 使用Thread()创建线程对象

import time
from threading import Thread

def task(name):
    print(f'{name} is running')  # 这行代码执行最快！
    time.sleep(3)
    print(f'{name} is over')

# 创建线程无需在__main__下面编写 但是为了统一 建议还是加上
t = Thread(target=task, args=('cloud',))
t.start()  # 这行代码是异步操作 主线程会继续往前走执行print
print('主线程')

为什么创建线程无需在main下编写？

说明创建线程没有发生导模块的操作。而是在进程开辟的内存空间内进行。

为什么子线程总是比主线程快？子线程和主线程真的是异步操作吗？

import time
from threading import Thread

print(2)
def task(name):
    print(f'{name} is running')
    time.sleep(3)
    print(f'{name} is over')

for i in range(1000):  # 开1000个子线程还是 还是子线程快。
                       # 为什么？不是异步吗？在开的子线程足够多的时候 可能主线程的print先执行吗？
    t = Thread(target=task, args=('cloud',))
    t.start()
print('主线程')

这里所谓的异步是：

开线程时 主线程代码会继续走 每个子线程代码也会执行 各走各的

而不是主线程等待子线程把函数运行完了 再启动下一个for循环 再创建一个线程

方式2 重写Thread类run方法

import time
from threading import Thread

class MyThread(Thread):

    def __init__(self, name):  # 重写init
        super().__init__()  # init里什么都不加 查看源码可发现全是默认参数
        self.name = name  # 给对象添加一个独有的属性

    def task1(self):
        print('hello im alice')

    def task2(self):
        print('hello im miku')

    def run(self):  # 重写run函数
        print('run is running')
        print(f'hello im {self.name}')
        time.sleep(1)
        self.task1()
        self.task2()  # 添加更多的函数...
        print('run is over')

obj = MyThread('cloud')
obj.start()
print('主线程')

'''
run is running
hello im cloud
主线程
hello im alice
hello im miku
run is over
'''

创建1000个进程 vs 创建1000个线程

from threading import Thread
import time

def task(name):
    print(f'{name} is running')
    time.sleep(0.1)
    print(f'{name} is over')

if __name__ == '__main__':
    # 1.创建100个进程
    # start_time = time.time()
    # p_list = []
    # for i in range(10):
    #     p = Process(target=task, args=('用户%s'%i,))
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:
    #     p.join()
    # print(time.time() - start_time)  # 0.8916168212890625

    # 2.创建100个线程
    start_time = time.time()
    t_list = []
    for i in range(10):
        t = Thread(target=task, args=('用户%s'%i,))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()  # 确保所有线程都执行结束再运行 主线程代码
    print(time.time() - start_time)  # 0.11295676231384277  # 开的数量越多线程开销小的优点越明显 # 受限于硬件我无法演示= =

print('主线程')

线程的诸多特性

# 1.join方法
让主线程代码等待子线程代码结束

验证线程数据共享

from threading import  Thread

money = 1000

def task():
    global money
    money = 666

t = Thread(target=task)
t.start()
t.join()
print(money)  # 666

查看线程名字 current_thread().name

from threading import Thread, current_thread

def task():
    print(f'子线程名：{current_thread().name} --> {current_thread()}')  # 查看的是此函数所在的子线程的名字！

t = Thread(target=task)
t.start()
print(f'主线程名：{current_thread().name} --> {current_thread()}')

验证线程在同一个进程 os.getpid()

import os
from threading import Thread

def task():
    print(f'子线程所在进程：{os.getpid()}')
for i in range(10):
    t = Thread(target=task)
    t.start()
print(f'主线程所在进程：{os.getpid()}')

进程下存活的线程数 active_count()

import os
import time
from threading import Thread, active_count, current_thread

def task():
    time.sleep(1)
    print(f'进程：{os.getpid()} 线程：{current_thread().name}')
for i in range(10):
    t = Thread(target=task)
    t.start()
print(active_count())  # 由于所有进程都睡一秒 这里是异步操作代码继续执行 所以存在的线程有： 10个睡着的子线程 1个主线程
'''
11
进程：46040 线程：Thread-6
进程：46040 线程：Thread-3
进程：46040 线程：Thread-10
进程：46040 线程：Thread-5
进程：46040 线程：Thread-1
进程：46040 线程：Thread-4
进程：46040 线程：Thread-2
进程：46040 线程：Thread-9
进程：46040 线程：Thread-7
进程：46040 线程：Thread-8
'''

补充

1.线程实现tcp并发
2.守护线程 使用方法同守护进程 在线程start之前设置其为守护线程(语法：threading.daemon = True)

GIL全局解释器锁

# 官方文档对GIL的解释
In CPython, the global interpreter lock, or GIL, is a mutex that prevents
multiple native threads from executing Python bytecodes at once. This lock is
necessary mainly because CPython’s memory management is not thread-safe.
(However, since the GIL exists, other features have grown to depend on the
guarantees that it enforces.

# 1.Python解释器的类型：
Cpython(常用) Jpython pypython
ps:GIL只在Cpython中存在！
GIL是Cpython解释器的特性 不是python语言的特性 

# 2.GIL本质也是一把互斥锁 用来阻止同一个进程内多个线程同时执行（线程并发）
首先线程并发需要多个cpu。GIL阻止多个线程同时执行，使得同一时间只能有一个线程工作，也只使用一个cpu。

# 3.GIL的存在是因为，Cpython解释器中针对多线程无法保存数据的安全。
Cpython内存管理（垃圾回收机制）不是线程安全的
当线程与垃圾回收线程并行时，线程刚创建的变量名还未绑定内存中的对象，此时垃圾回收线程会发现此变量名的引用计数为0，会立即将此变量名销毁，这就会导致线程报错。
（回忆：引用计数 标记清除 分代回收）

# 4.所有解释型语言 都逃不开垃圾回收线程 和 其他线程 抢锁的过程。
错的不是python，是世界！
编译型语言没有锁的概念。 这也是编译型语言快的原因。

流程推导（重要）

垃圾回收线程问题：



垃圾线程与多个线程抢锁：

抢到锁的线程，也就获得了解释器的使用权。加上GIL确保同一时间只有一个线程在运行。

多个cpu情况

验证GIL的存在

from threading import Thread
num = 100

def task():
    global num
    num = num - 1

t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()  # 确保线程执行完 再print(num)
print(num) # 0

'''
如果多个线程可以同时执行 就可能发生多个进程同时人让num减1
比如10个线程同时拿到num=100 然后将num-1之后再赋值给num
也就是多次将99赋值给num 也就相当于这10个线程只让num减了1 >>> num=99
'''

阻塞验证

import time
from threading import Thread
num = 100

def task():
    global num
    count = num
    time.sleep(0.5)  # 阻塞导致每个线程拿到的 count都是100
    num = count - 1  # 每个线程都将num赋值为99

t_list = []

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

print(num)  # 99
'''
IO阻塞 CPU会走 导致GIL锁释放 抢到也没用 等阻塞结束再抢锁
然后每个线程的count全是100 每个线程都做一件事就是将num = 100 -1
'''

GIL与普通互斥锁

既然CPython解释器中有GIL 那么我们以后写代码是不是就不需要操作锁了!!!
"""
GIL只能够确保同进程内多线程数据不会被垃圾回收机制弄乱
	并不能确保程序里面的数据是否安全

核心：对于不同的数据需要加不同的锁
"""

# 1.在主线程创建锁，在子线程加锁解决上面的问题
import time
from threading import Thread, Lock
num = 100

def task(lock):
    global num
    lock.acquire()  # 抢锁
    count = num
    time.sleep(0.1)
    num = count - 1
    lock.release()  # 放锁

t_list = []
lock = Lock()

for i in range(100):
    t = Thread(target=task, args=(lock,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()

print(num)  # 0  # 经历一段时间的等待

python多线程是否有用？

需要分情况:
	# 情况1
		 单个CPU
		 多个CPU
	# 情况2
		IO密集型(代码有IO操作)
		计算密集型(代码没有IO)

# 1.单个CPU
	IO密集型
    	多进程: 申请额外的空间 消耗更多的资源
    	多线程：消耗资源相对较少 通过多道技术
      ps:多线程有优势!!!

	计算密集型
    	多进程：申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
        多线程：消耗资源相对较少 通过多道技术(总耗时+切换)
      ps:多线程有优势!!!

# 2.多个CPU
	IO密集型
        多进程：总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
        多线程：总耗时(单个进程的耗时+IO)
       ps:多线程有优势!!!

	计算密集型
    	多进程：总耗时(单个进程的耗时)
    	多线程：总耗时(多个进程的综合)
       ps:多进程完胜!!!

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

def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i

if __name__ == '__main__':
    # print(os.cpu_count())  # 12  查看当前计算机CPU个数
    start_time = time.time()
    # p_list = []
    # for i in range(12):  # 一次性创建12个进程
    #     p = Process(target=work)
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:  # 确保所有的进程全部运行完毕
    #     p.join()
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时

"""
计算密集型
    多进程:5.665567398071289
    多线程:30.233906745910645
"""

def work():
    time.sleep(2)   # 模拟纯IO操作

if __name__ == '__main__':
    start_time = time.time()
    # t_list = []
    # for i in range(100):
    #     t = Thread(target=work)
    #     t.start()
    # for t in t_list:
    #     t.join()
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))

"""
IO密集型
    多线程:0.0149583816528320
    多进程:0.6402878761291504
"""

'''进程的时间耗费在空间的申请 线程也要睡2s
但是他的优势在开销小 （ps:别忘了，线程只能用一个CPU）'''

死锁现象

from threading import Thread,Lock
import time

mutexA = Lock()  # 产生一把锁
mutexB = Lock()  # 产生一把锁

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')

    def func2(self):
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        time.sleep(1)
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')

for i in range(10):
    obj = MyThread()
    obj.start()

'''
------->>------>>------>>---time line------>>--------->>------->>-------->>

线程1：抢A --> 抢B --> 放B --> 放A --> 抢B --> sleep --> 抢A（阻塞）  A在进程2手中

线程2：                       抢A --> 抢B（阻塞）  B在进程1手中
'''

信号量

1.在python并发编程中信号量相当于多把互斥锁(公共厕所)
2.在有些知识中信号量的意思是达到某个条件自动触发其他条件
'''
我们之前使用lock产生的是单把锁
    类似于单间厕所
信号量相当于一次性创建多间厕所
    类似于公共厕所
'''

from threading import Thread, Semaphore
import time
import random

sp = Semaphore(5)  # 一次性产生五把锁

class MyThread(Thread):
    def run(self):
        sp.acquire()
        print(self.name)
        time.sleep(random.randint(1, 3))
        sp.release()

for i in range(20):
    t = MyThread()
    t.start()

event事件

from threading import Thread, Event
import time

event = Event()  # 类似于造了一个红绿灯

def light():
    print('红灯亮着的 所有人都不能动')
    time.sleep(3)
    print('绿灯亮了 油门踩到底 给我冲!!!')
    event.set()

def car(name):
    print('%s正在等红灯' % name)
    event.wait()
    print('%s加油门 飙车了' % name)

t = Thread(target=light)
t.start()
for i in range(20):
    t = Thread(target=car, args=('熊猫PRO%s' % i,))
    t.start()
'''
在同一个进程下 你的event.set也在一个内存中
所以可以在进程中创建event对象 控制不同的线程
'''

进程池与线程池

进程和线程能否无限制的创建 不可以
因为硬件的发展赶不上软件 有物理极限 如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机奔溃

池
	降低程序的执行效率 但是保证了计算机硬件的安全
进程池
	提前创建好固定数量的进程供后续程序的调用 超出则等待
线程池
	提前创建好固定数量的线程供后续程序的调用 超出则等待

线程池

基本使用

import random
import time
from concurrent.futures import ThreadPoolExecutor

# 1.产生含有固定数量线程的线程池
pool = ThreadPoolExecutor(5)

def task():
    print('task is running')
    time.sleep(random.randint(1, 3))
    print('task is over')

# 2.将任务提交给线程池即可
for i in range(100):  # 5个线程处理100个任务 谁有空谁来
    pool.submit(task)

固定的线程

from threading import current_thread
import random
import time
from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor(5)

def task():
    print(f'{current_thread().name} is running')
    time.sleep(random.randint(1, 3))
    print('task is over')

for i in range(100):
    pool.submit(task)
'''
这5个线程提前创建好 然后就固定下来
不是之前的动态创建、动态销毁
'''

查看源码

看红框即可：

进程池

from concurrent.futures import ProcessPoolExecutor
import os
import time

pool = ProcessPoolExecutor(5)

def task():
    print(f'进程：{os.getpid()} ')
    time.sleep(1)

if __name__ == '__main__':
    for i in range(6):
        pool.submit(task)
# 进程池中的进程也是创建好了就固定下来了 一共5个
'''
进程：20180
进程：11252
进程：21060
进程：21116
进程：46100
进程：20180
'''

task传参(线程池也这样传)

from concurrent.futures import ProcessPoolExecutor
import os
import time

pool = ProcessPoolExecutor(5)

def task(msg):
    print(f'进程：{os.getpid()} {msg}')
    time.sleep(1)

if __name__ == '__main__':
    for i in range(6):
        pool.submit(task, 'hello')  # 直接在括号里面写 # 支持位置参数、关键字参数

'''重新运行，进程池也会重建
进程：22056 hello
进程：20220 hello
进程：35120 hello
进程：17056 hello
进程：16704 hello
进程：22056 hello
'''

回调函数

from concurrent.futures import ProcessPoolExecutor
import os
import time

pool = ProcessPoolExecutor(5)

def task():
    print(f'进程：{os.getpid()}')
    time.sleep(1)
    return f'进程：{os.getpid()} >>> 返回值'

def call_back_func(a):  # 回调函数 当进程将task运行结束之后 立即执行回调函数 回调函数可以获取task的返回值
    print(a)
    print(a.result())  # result用于获取task返回值

if __name__ == '__main__':
    for i in range(6):
        pool.submit(task).add_done_callback(call_back_func)  # 在add_done_callback里面放回调函数

'''回调函数建议写法：
def task(*args, **kwargs):
    pass
args是个元祖 里面存放着对象 对象可以调用result
'''

'''
函数的返回值又回调函数接收 只要进程的任务结束并且有任务的结果
就会触发炸弹 调用回调函数 异步回调 一个任务有结果了
就可以拿一个回调函数接收他   然后进程回到进程池？
进程什么时候回到进程池？回调函数执行完之后吗？
'''

协程

协程：目的是单线程实现并发的效果
'''自己写代码检测IO 一旦有发现有IO操作，程序跳转执行别的代码，保持程序运行
自始至终欺骗cpu'''

"""
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
	在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
	实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
	(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
		核心:自己写代码完成切换+保存状态
"""

monkey模块

import time
from gevent import monkey;

monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn

def func1():
    print('func1 running')
    time.sleep(3)
    print('func1 over')

def func2():
    print('func2 running')
    time.sleep(5)
    print('func2 over')

if __name__ == '__main__':
    start_time = time.time()
    # func1()
    # func2()
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)  # 8.01237154006958   协程 5.015487432479858!

代码在两个sleep之间左右横跳，让cpu觉得代码在一直运行，故cpu不会离开：

协程实现并发

import socket
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn

def communication(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())

def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    while True:
        sock, addr = server.accept()  # IO操作
        spawn(communication, sock)

s1 = spawn(get_server)
s1.join()

如何不断的提升程序的运行效率
	多进程下开多线程 多线程下开协程