1. 线程queue
# queue队列：用法与进程Queue一样
import queue
q = queue.Queue() # 先进先出
q.put('123')
q.put('qweqwe')
print(q.get()) # 123
print(q.get()) # qweqwe
# print(q.get()) # 等待
q.task_done()
q.task_done()
q.join()
q = queue.LifoQueue() # 先进后出 实现堆栈的效果
q.put('aa')
q.put('bb')
q.put('cc')
print(q.get()) # cc
print(q.get()) # bb
print(q.get()) # aa
# 存储数据时可设置优先级的队列
q = queue.PriorityQueue() # 可以根据优先级取数据
# put进入一个元组,元组的第一个元素是优先级
# (通常是数字,也可以是非数字之间的比较),数字越小优先级越高，优先级高的优先出队
q.put((50,'a'))
q.put((80,'b'))
q.put((1,'c'))
print(q.get()) # (1, 'c')
print(q.get()) # (50, 'a')
print(q.get()) # (80, 'b')
2. 线程定时器
from threading import Timer
import time
def task():
print('线程 start')
time.sleep(2)
print('线程 end')
t = Timer(4,task) # 过了4s后开启了一个线程
t.start()
3. 基于多线程的socket
# ************server.py*************
import socket
from threading import Thread
def task(conn):
while True:
try:
data = conn.recv(1024)
if len(data) == 0:
break
else:
print(data)
conn.send(data.upper())
except Exception:
break
conn.close()
def server_demo():
soc = socket.socket()
soc.bind(('127.0.0.1',8000))
soc.listen(5)
while True:
print('等待客户端连接')
conn, addr = soc.accept()
print('已有客户连接', addr)
t = Thread(target=task,args=(conn,))
t.start()
if __name__ == '__main__':
server_demo()
# ************client.py*************
import socket
from threading import Thread,currentThread
def client_demo():
soc = socket.socket()
soc.connect(('127.0.0.1',8000))
for i in range(1):
msg = f'{currentThread().name}'
if len(msg) == 0:
continue
soc.send(msg.encode('utf-8'))
data = soc.recv(1024)
print(data)
soc.close()
if __name__ == '__main__':
for i in range(20):
t = Thread(target=client_demo)
t.start()
4. 进程池和线程池
'''
进程池线程池：
池的功能限制启动的进程数或线程数
什么时候限制？
当并发的任务数量远远大于计算机所能承受的范围，即无法一次性开启过多的任务数量
应该考虑去限制进程数或线程数，从而保证服务器不崩
理解为提交任务的两种方式：
同步：提交了一个任务，必须等任务执行完了拿到返回值，才能执行下一行代码
异步：提交了一个任务，不要等执行完了，可以直接执行下一行代码
不要和信号量用混了，线程池里面始终没有产生新的线程，比如ThreadPoolExecutor(4),所以的任务始终是由这4个线程去执行
'''
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time
# 进程池/线程池的基本用法1
def task(i):
# print(f'线程 {currentThread().name} 在执行任务 {i}')
print(f'进程 {current_process().name} 在执行任务 {i}')
time.sleep(1)
return i**2
if __name__ == '__main__':
# pool = ThreadPoolExecutor(4) # 池子里只有4个线程
pool = ProcessPoolExecutor(4) # 池子里只有4个线程
for i in range(20):
future = pool.submit(task,i) # task任务要做20次，4个线程负责做这个事
print(future.result()) # 如果没有结果一直等待拿到结果，导致了所以任务都在串行
# 进程池/线程池的基本用法2
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time
def task(i):
# print(f'线程 {currentThread().name} 在执行任务 {i}')
print(f'进程 {current_process().name} 在执行任务 {i}')
time.sleep(1)
return i**2
if __name__ == '__main__':
# pool = ThreadPoolExecutor(4) # 池子里只有4个线程
pool = ProcessPoolExecutor(4) # 池子里只有4个线程
fu_list = []
for i in range(20):
future = pool.submit(task,i) # task任务要做20次，4个线程负责做这个事
# print(future.result()) # 如果没有结果一直等待拿到结果，导致了所以任务都在串行
fu_list.append(future)
pool.shutdown() # 关闭了池的入口，会等待所有的任务执行完，结束阻塞
for fu in fu_list:
print(fu.result()) # 拿不到之会阻塞在这里
# 回调函数
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time
def task(i):
print(f'线程 {currentThread().name} 在执行任务 {i}')
# print(f'进程 {currentThread().name} 在执行任务 {i}')
time.sleep(1)
return i**2
def parse(future):
# 处理拿到的结果
print(future.result())
if __name__ == '__main__':
pool = ThreadPoolExecutor(4)
# pool = ProcessPoolExecutor(4)
fu_list = []
for i in range(20):
future = pool.submit(task,i)
future.add_done_callback(parse) # 绑定回调函数
# 为当前任务绑定了一个函数,在当前任务执行结束的时候会触发这个函数,
# 会把future对象作为参数传给函数
# 这个称之为回调函数,处理完了回来就调用这个函数.
5. 协程
'''
python的线程用的是操作系统原生的线程
协程：单线程下实现并发
并发：切换+保存状态
多线程：操作系统帮你实现的，如果遇到io切换，执行时间过长也会切换，实现一个雨露均沾的效果
什么样的协程有意义？
遇到io切换的时候才有意义
具体：
协程概念本质是程序员抽象出来的，操作系统根本不知道协程存在，也就说来了一个线程我自己遇到io，我自己线程内部直接切到自己的别的任务上了,操作系统跟本发现不了,
也就是实现了单线程下效率最高.
优点：
自己控制要比操作系统切换快得多
缺点：
对比多线程
自己要检测所有的io，但凡有一个阻塞整体都跟着阻塞
对比多进程
无法利用多核优势
为什么要用协程(遇到io切换)？
自己控制切换要比操作系统快得多，降低了单个线程的io时间
'''
import time
def eat():
print('eat 1')
# 疯狂的计算没有io
time.sleep(2)
# for i in range(1000000000):
# i + 1
def play():
print('play 1')
# 疯狂的计算没有io
time.sleep(3)
# for i in range(1000000000):
# i + 1
start = time.time()
play()
eat()
end = time.time()
print(end - start) # 5.002086877822876
# yield关键字
import time
def func1():
while True:
1000000 + 1
yield
def func2():
g = func1()
for i in range(100000000):
i+1
next(g)
start = time.time()
func2()
stop = time.time()
print(stop - start) # 24.08209800720215
# 对比通过yeild切换运行的时间反而比串行更消耗时间，这样实现的携程是没有意义的
import time
def func1():
for i in range(100000000):
i + 1
def func2():
for i in range(100000000):
i + 1
start = time.time()
func1()
func2()
stop = time.time()
print(stop - start) # 18.695963144302368
# gevent
'''
Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程
在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程
Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度
'''
import gevent
def eat():
print('eat 1')
gevent.sleep(2) # 模拟的是gevent可以识别的io阻塞
print('eat 2')
def play():
print('play 1')
gevent.sleep(3)
print('play 2')
g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
# 或者 gevent.joinall([g1,g2])
'''
time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用
***from gevent import monkey;monkey.patch_all()*** 打补丁,就可以识别了
必须放到被打补丁者的前面，如time，socket模块之前
'''
from gevent import monkey
monkey.patch_all()
import gevent
import time
def eat():
print('eat 1')
time.sleep(2)
print('eat 2')
def play():
print('play 1')
time.sleep(3)
print('play 2')
start = time.time()
g1 = gevent.spawn(eat)
g2 = gevent.spawn(play)
g1.join()
g2.join()
end = time.time() # 如果打好了补丁 就可以识别非gevent.sleep阻塞进行切换
print(end - start) # 3.0185744762420654