1.死锁 与 递归锁（了解）
死锁现象
from threading import Thread
from threading import Lock
from threading import RLock # 递归锁
import time
mutexA = Lock()
mutexB = Lock()
# print(mutexA is mutexB) # False
# 类 只要加括号多次 产生的肯定是不同的对象
# 如果你想要实现多次加括号得到的是相同的对象 要用到单例模式
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print(f'{self.name} 抢到了 func1的A锁') # 获取当前线程名
mutexB.acquire()
print(f'{self.name} 抢到了 func1的B锁') # 获取当前线程名
mutexB.release()
mutexA.release()
def func2(self):
mutexB.acquire()
print(f'{self.name} 抢到了 func2的B锁') # 获取当前线程名
time.sleep(2)
mutexA.acquire()
print(f'{self.name} 抢到了 func2的A锁') # 获取当前线程名
mutexA.release()
mutexB.release()
if __name__ == '__main__':
for i in range(10):
t = MyThread()
t.start()
# Thread-1 抢到了 func1的A锁
# Thread-1 抢到了 func1的B锁
# Thread-1 抢到了 func2的B锁
# Thread-2 抢到了 func1的A锁
递归锁（了解）
递归锁特点：
可以被连续地acquir和release
但是只能被第1个抢到的这把锁 执行上述操作
它的内部有1个计数器 每acquire 1次 计数+1， 每release 1次 计数—1
只要计数不为0 ，那么其他人都无法抢到该锁
from threading import Thread
from threading import RLock # 递归锁
import time
mutexA = mutexB = RLock()
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print(f'{self.name} 抢到了 func1的A锁') # 获取当前线程名
mutexB.acquire()
print(f'{self.name} 抢到了 func1的B锁') # 获取当前线程名
mutexB.release()
mutexA.release()
def func2(self):
mutexB.acquire()
print(f'{self.name} 抢到了 func2的B锁') # 获取当前线程名
time.sleep(2)
mutexA.acquire()
print(f'{self.name} 抢到了 func2的A锁') # 获取当前线程名
mutexA.release()
mutexB.release()
if __name__ == '__main__':
for i in range(10):
t = MyThread()
t.start()
# Thread-1 抢到了 func1的A锁
# Thread-1 抢到了 func1的B锁
# Thread-1 抢到了 func2的B锁
# Thread-1 抢到了 func2的A锁
# Thread-2 抢到了 func1的A锁
# Thread-2 抢到了 func1的B锁
# Thread-2 抢到了 func2的B锁
# Thread-2 抢到了 func2的A锁
# Thread-4 抢到了 func1的A锁
# ......
2.信号量（了解）
信号量 在不同的阶段 可能对应不同的技术点
在并发编程中 信号量 指的是 锁！！！
如果我们将互斥锁 比喻成 一个厕所的话（家庭厕所）
那么 信号量 就相当于 多个厕所（公共厕所）
代码实现：
from threading import Thread
from threading import Semaphore
import time
import random
'''
利用random模块实现打印随机验证码（搜狗的一道笔试题）
'''
sm = Semaphore(5) # 括号内写数字 写几 就表示开设几个坑位
def task(name):
sm.acquire()
print(f'{name} 正在蹲坑')
# time.sleep(3)
time.sleep(random.randint(1, 5))
sm.release()
if __name__ == '__main__':
for i in range(20):
t = Thread(target=task, args=(f'伞兵{i}号',))
t.start()
3.Event事件（了解）
一些进程/线程 需要等待另外一些进程/线程运行完毕之后 才能运行，类似于发射信号一样。
from threading import Thread
from threading import Event
import time
event = Event() # 造了一个红绿灯
def light():
print('红灯亮')
time.sleep(3)
print('绿灯亮')
# 告诉等待红灯的人 可以走了
event.set()
def car(name):
print(f'{name} 正在等红灯')
event.wait() # 等待别人给你发消息
print(f'{name} 加油门 飙车走了')
if __name__ == '__main__':
t = Thread(target=light)
t.start()
for i in range(20):
# t = Thread(target=car, args=(f'{i}'))
t = Thread(target=car, args=('%s' % i))
t.start()
4.线程q（了解）
同一个进程下 多个线程数据是共享的
为什么同一个进程下 还会去使用队列呢？
因为：
队列 = 管道 + 锁
所以：
用队列还是为了保证数据的安全
'''
同一个进程下 多个线程数据是共享的
为什么同一个进程下 还会去使用队列呢？
因为：
队列 = 管道 + 锁
所以：
用队列还是为了保证数据的安全
'''
import queue
# 我们现在使用的队列 都是只能在本地测试使用的
# 1.队列q 先进先出
# q = queue.Queue(3)
# q.put(1)
# q.get()
# q.get_nowait()
# q.get(timeout=3)
# q.full()
# q.empty()
# 2.后进先出q
# q = queue.LifoQueue(3) # Last in first out
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get()) # 3
# 3.优先级q 你可以给放入队列中的数据 设置进出的优先级
q = queue.PriorityQueue(4)
q.put((10, '111')) # (优先级, '数据')
q.put((101, '222')) # (优先级, '数据')
q.put((0, '333')) # (优先级, '数据')
q.put((1, '444')) # (优先级, '数据')
print(q.get()) # (0, '333')
# put括号内放一个元组 第一个数字表示优先级
# 注意：数字越小 优先级越高！！！
5.进程池 与 线程池（掌握）
先回顾之前TCP服务端实现并发的效果是什么玩儿的
每来一个人 就要开设一个进程 或者 线程 去处理
无论是开设进程也好 还是开设线程也好 是不是都需要消耗资源
只不过 开设线程的消耗 比 开设进程的稍微小一点而已
我们是不可能做到无限制的开设进程和线程的 因为计算机硬件的资源跟不上！！！
硬件的开发速度 远远赶不上软件
我们的宗旨 应该是：在保证计算机硬件 能够正常工作的情况下 最大限度地利用它
# 池的概念 == > 接待室
池 是用来保证计算机硬件安全的情况下 最大限度地利用计算机
它 降低了程序的运行效率 但是保证了计算机硬件的安全 从而让你写的程序能够正常运行
初始：
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
# 线程池
pool = ThreadPoolExecutor(5) # 池子里面 固定只有5个线程
# 括号内可以传数字 不传的话 默认会开设当前计算机CPU核心数的 5倍的线程
'''
池子造出来之后 里面会固定存在5个线程
这5个线程 不会出现重复创建和销毁的过程
池子的使用 非常的简单
你只需要将需要做的任务 往池子中提交即可 自动会有人来服务你
'''
def task(n):
print(n)
time.sleep(2)
return n**n
'''
任务的提交方式：
同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
异步：提交任务之后 不等待任务的返回结果 继续往下执行
返回结果 如何获取？？？
'''
# pool.submit(task, 1) # 朝池子中 提交任务 异步提交
# print('主') # 1主
for i in range(20): # 朝池子中 提交20个任务
res = pool.submit(task, i) # 0<Future at 0x32e8190 state=running>
print(res.result()) # result方法 同步提交 join方法
'''
程序 从 并发 变成了 串行
任务的结果 为什么打印的是None
打印的是任务的return返回值
print(res.result()) 拿到的就是异步提交的任务的返回结果
'''
进阶：
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
# 线程池
pool = ThreadPoolExecutor(5) # 池子里面 固定只有5个线程
# 括号内可以传数字 不传的话 默认会开设当前计算机CPU核心数的 5倍的线程
'''
池子造出来之后 里面会固定存在5个线程
这5个线程 不会出现重复创建和销毁的过程
池子的使用 非常的简单
你只需要将需要做的任务 往池子中提交即可 自动会有人来服务你
'''
def task(n):
print(n)
time.sleep(2)
return n**n
'''
任务的提交方式：
同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
异步：提交任务之后 不等待任务的返回结果 继续往下执行
返回结果 如何获取？？？
'''
# pool.submit(task, 1) # 朝池子中 提交任务 异步提交
# print('主') # 1主
t_list = []
for i in range(20): # 朝池子中 提交20个任务
res = pool.submit(task, i) # 0<Future at 0x32e8190 state=running>
# print(res.result()) # result方法 同步提交 join方法
t_list.append(res)
for t in t_list:
print('>>>>:', t.result()) # 肯定是有序的
'''
程序 从 并发 变成了 串行
任务的结果 为什么打印的是None
打印的是任务的return返回值
print(res.result()) 拿到的就是异步提交的任务的返回结果
'''
高阶：
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
# 线程池
pool = ThreadPoolExecutor(5) # 池子里面 固定只有5个线程
# 括号内可以传数字 不传的话 默认会开设当前计算机CPU核心数的 5倍的线程
'''
池子造出来之后 里面会固定存在5个线程
这5个线程 不会出现重复创建和销毁的过程
池子的使用 非常的简单
你只需要将需要做的任务 往池子中提交即可 自动会有人来服务你
'''
def task(n):
print(n)
time.sleep(2)
return n**n
'''
任务的提交方式：
同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
异步：提交任务之后 不等待任务的返回结果 继续往下执行
返回结果 如何获取？？？
'''
# pool.submit(task, 1) # 朝池子中 提交任务 异步提交
# print('主') # 1主
t_list = []
for i in range(20): # 朝池子中 提交20个任务
res = pool.submit(task, i) # 0<Future at 0x32e8190 state=running>
# print(res.result()) # result方法 同步提交 join方法
t_list.append(res)
# 等待线程池中 所有的任务 执行完毕之后 再继续往下执行
pool.shutdown() # 关闭线程池 等待线程池中所有的任务进行完毕
for t in t_list:
print('>>>>:', t.result()) # 肯定是有序的
'''
程序 从 并发 变成了 串行
任务的结果 为什么打印的是None
打印的是任务的return返回值
print(res.result()) 拿到的就是异步提交的任务的返回结果
'''
终极：
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
import os
# 线程池
# pool = ThreadPoolExecutor(5) # 池子里面 固定只有5个线程
# 括号内可以传数字 不传的话 默认会开设当前计算机CPU核心数的 5倍的线程
pool = ProcessPoolExecutor(5)
# 括号内可以传数字 不传的话 默认会开设当前计算机CPU核心数的线程
'''
池子造出来之后 里面会固定存在5个线程
这5个线程 不会出现重复创建和销毁的过程
池子的使用 非常的简单
你只需要将需要做的任务 往池子中提交即可 自动会有人来服务你
'''
def task(n):
print(n)
time.sleep(2)
return n**n
def callback(n):
print('返回的是：', n)
'''
任务的提交方式：
同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
异步：提交任务之后 不等待任务的返回结果 继续往下执行
返回结果 如何获取？？？
异步提交任务的返回结果 应该通过回调机制来获取
回调机制：
一旦该任务有结果 立刻触发爆炸
'''
# pool.submit(task, 1) # 朝池子中 提交任务 异步提交
# print('主') # 1主
if __name__ == '__main__':
t_list = []
for i in range(20): # 朝池子中 提交20个任务
# res = pool.submit(task, i) # 0<Future at 0x32e8190 state=running>
res = pool.submit(task, i).add_done_callback(callback)
# print(res.result()) # result方法 同步提交 join方法
t_list.append(res)
# # 等待线程池中 所有的任务 执行完毕之后 再继续往下执行
# pool.shutdown() # 关闭线程池 等待线程池中所有的任务进行完毕
#
# for t in t_list:
# print('>>>>:', t.result()) # 肯定是有序的
'''
程序 从 并发 变成了 串行
任务的结果 为什么打印的是None
打印的是任务的return返回值
print(res.result()) 拿到的就是异步提交的任务的返回结果
'''
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
pool = ProcessPoolExecutor(5)
pool.submit(task, i).add_done_callback(callback)
6.协程（了解）
进程：资源单位
线程：执行单位
协程：这个概念 完全是程序员自己YY出来的 根本不存在
单线程下 实现并发（欺骗CPU）
我们程序员自己在代码层面上 检测我们所有的IO操作
一旦遇到了IO 我们在代码级别完成切换
这样给CPU的感觉 是你这个程序一直在运行 没有IO
从而提升程序的运行效率
多道技术：
切换 + 保存状态
CPU两种切换：
1.程序遇到IO
2.程序长时间占用
TCP服务端：
accept
recv
代码如何做到：
切换 + 保存状态
切换：
切换不一定是提升效率 也有可能是降低效率
IO切换：提升效率
没有IO切：降低效率
保存状态：
保存上一次我执行的状态 下一次来接着上一次的操作继续往后执行
yield
验证 切换是否就一定提升效率
import time
# 串行执行计算密集型的任务 耗时：1.8605678081512451秒
def func1():
for i in range(10000000):
i + 1
def func2():
for i in range(10000000):
i + 1
start_time = time.time()
func1()
func2()
print(time.time() - start_time)
# 切换 + yield 1.9720776081085205
import time
def func1():
while True:
10000000 + 1
yield
def func2():
g = func1() # 先初始化出 生成器
for i in range(10000000):
i + 1
next(g)
start_time = time.time()
func2()
print(time.time() - start_time)
gevent模块（了解）
安装：在终端输入 pip3 install gevent
from gevent import monkey;monkey.patch_all()
import time
from gevent import spawn
'''
gevent模块 本身无法检测常见的一些IO操作
在使用的时候 需要你额外地导入一句话：
from gevent import monkey
monkey.patch_all()
又由于上面的2句话 在使用gevent模块的时候 肯定是要导入的
所以，还支持简写：
from gevent import monkey;monkey.patch_all()
'''
def heng():
print('哼!')
time.sleep(2)
print('哼！！')
def ha():
print('哈!')
time.sleep(3)
print('哈！！')
def heiheihei():
print('嘿嘿嘿!')
time.sleep(5)
print('嘿嘿嘿！！')
start_time = time.time()
g1 = spawn(heng)
g2 = spawn(ha)
g3 = spawn(heiheihei)
g1.join() # 等待被监测的任务执行完毕 再往后继续执行
g2.join()
g3.join()
# heng()
# ha()
print(time.time() - start_time)
# 哼!
# 哈!
# 嘿嘿嘿!
# 哼！！
# 哈！！
# 嘿嘿嘿！！
# 5.022841453552246
7.协程实现TCP服务端的并发效果（了解）
服务端：
from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn
def communication(conn):
while True:
try:
data = conn.recv(1024)
if len(data) == 0:
break
conn.send(data.upper())
except ConnectionResetError as e:
print(e)
break
conn.close()
def server(ip, port):
server = socket.socket()
server.bind((ip, port))
server.listen(5)
while True:
conn, addr = server.accept()
spawn(communication, conn)
if __name__ == '__main__':
g1 = spawn(server, '127.0.0.1', 8080)
g1.join()
客户端：
from threading import Thread, current_thread
import socket
def x_client():
client = socket.socket()
client.connect(('127.0.0.1', 8080))
n = 0
while True:
msg = f'{current_thread().name} say hello {n}'
n += 1
client.send(msg.encode('UTF-8'))
data = client.recv(1024)
print(data.decode('UTF-8'))
if __name__ == '__main__':
for i in range(500):
t = Thread(target=x_client)
t.start()
总结：
理想状态：
我们可以通过
多进程下面 开设多线程
多线程下面 开设协程
从而使我们的程序 执行效率提升