1.线程的其他方法
from threading import Thread,current_thread
import time
import threading
def f1(n):
time.sleep(1)
print('子线程名称',current_thread().getName())#获取线程名
if __name__=='__main__':
t1=Thread(target=f1,args=(1,))
t1.start()
print('主线程名称',current_thread().getName())
print('主进程id',current_thread().ident)
print(current_thread())#当前线程的对象
print(threading.enumerate())#当前正在运行的线程的一个列表
print(threading.active_count())#当前正在运行的线程的数量
#########结果########
主线程名称 MainThread
主进程id 7512
<_MainThread(MainThread, started 7512)>
[<_MainThread(MainThread, started 7512)>, <Thread(Thread-1, started 5680)>]
2
子线程名称 Thread-1
2.线程队列
import queue
###先进先出
q=queue.Queue(3)
q.put(1)
q.put(2)
print('当前队列内容长度',q.qsize())
q.put(3)
print('查看队列是否满了',q.full()) print(q.get())
print(q.get())
print('查看队列是否为空',q.empty())
print(q.get())#在多打一个get会形成程序阻塞
print('查看队列是否为空',q.empty())
try:
q.get_nowait()#报错queue.Empty
except Exception:
print('队列空了')
############################
当前队列内容长度 2
查看队列是否满了 True
1
2
查看队列是否为空 False
3
查看队列是否为空 True
队列空了
####先进后出 类似于栈
import queue
q = queue.LifoQueue(3)
#
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())
##############
3
2
1
####优先级队列
import queue
q=queue.PriorityQueue(5)
q.put((5,'alex'))
q.put((2,'宝宝'))
q.put((4,'大力'))
print(q.get())
print(q.get())
print(q.get())
##########
(2, '宝宝')
(4, '大力')
(5, 'alex')
#如果优先级数字相同,如果数据类型不同会报错,类型相同会对比元祖中的第二行英语字母
3.线程池
map方法
import time
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread def func(n):
time.sleep(1)
print(n)
# print(n,current_thread().ident) if __name__ == '__main__':
t_p = ThreadPoolExecutor(4)
map_res = t_p.map(func,range(10)) #异步执行的,map自带join功能
print(map_res)
print([i for i in map_res])
#######################
<generator object Executor.map.<locals>.result_iterator at 0x00000000029E94F8>
012 3 4
5
6
7
89
[None, None, None, None, None, None, None, None, None, None]#会取不到值
concurrent.futures 写法
import time
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(n):
time.sleep(0.1)#此处等待一秒是为了将取值时候的打印结果进行区分
# print(n)
return n
if __name__ == '__main__':
t_p = ThreadPoolExecutor(4)#可以进行线程进程切换
# t_p=ProcessPoolExecutor(4)
t_res_lst = []
for i in range(10):
res_obj =t_p.submit(func,i) #提交执行函数,返回一个结果对象,i作为任务函数的参数
t_res_lst.append(res_obj)
t_p.shutdown() #起到原来的close阻止新任务进来 + join的作用，等待所有的线程执行完毕
# print("t_res_lst",t_res_lst) #<Future at 0x1fa10a43400 state=finished returned int> 加了shutdown后全部变为finished
#<Future at 0x19d37f5c7f0 state=running>, <Future at 0x19d37f5c9b0 state=pending>不加shutdo时
for e_res in t_res_lst:
print(e_res.result())
# t_p.shutdown()
#在不加shutdown时,主线程在循环列表时,也是每一个进行取值,
# 但是由于可以有四个对象可以一起取值,(拿前四个为例,)
# 也就是当列表循环到4个时此时会等待将近1s
# 因为在执行函数有停留,但线程池可以四个同时执行,因此会有4个结果一起出来
#但是当加了shutdown时,此时线程会全部执行完毕,然后在列表里是,此时的对象已经全部执行完毕
########################
0
1
2
3
4
5
6
7
8
9
4.协程
协程本质上就是一个线程，以前线程任务的切换是由操作系统控制的，遇到I/O自动切换，在我们自己的程序里面来控制任务的切换。
现在我们用协程的目的就是较少操作系统切换的开销（开关线程，创建寄存器、堆栈等，在他们之间进行切换等），
import gevent
from gevent import monkey;monkey.patch_all()#本身不认识其他模块中的IO操作，但是如果我们在导入其他模块之前执行 就能够认识
import time def f1():
print('第一次f1')
# print(threading.current_thread().getName())
# gevent.sleep(1)
time.sleep(2)
print('第二次f1')
def f2():
# print(threading.current_thread().getName())
print('第一次f2')
# gevent.sleep(2)
time.sleep(2)
print('第二次f2')
s = time.time()
g1 = gevent.spawn(f1) #异步提交了f1任务
g2 = gevent.spawn(f2) #异步提交了f2任务
# g1.join()
# g2.join()
gevent.joinall([g1,g2])
e = time.time()
print('执行时间:',e-s)
print('主程序任务')
#######################
第一次f1
第一次f2
第二次f1
第二次f2
执行时间: 2.0021142959594727
主程序任务
下面是理解 :可看 可不看
#####生成器写法
import time
def f1():
for i in range(2):
time.sleep(0.5)
print('f1>>',i)
yield
def f2():
g = f1()
for i in range(2):
time.sleep(0.5)
print('f2>>', i)
next(g)
f1()
f2()
############
f2>> 0
f1>> 0
f2>> 1
f1>> 1
#######greenlet模块
import time
from greenlet import greenlet
def f1(s):
print('第一次f1'+s)
g2.switch('taibai') #切换到g2这个对象的任务去执行
time.sleep(1)
print('第二次f1'+s)
g2.switch()
def f2(s):
print('第一次f2'+s)
g1.switch()
time.sleep(1)
print('第二次f2'+s)
g1 = greenlet(f1) #实例化一个greenlet对象,并将任务名称作为参数参进去
g2 = greenlet(f2)
g1.switch('alex') #执行g1对象里面的任务
###########
#首先会执行g1的switch(alex)也就是执行f1 print('第一次f1'+alex)
#往下就会执行f2 进行传参taibai 会打印 第一次f2taibai
#往下 执行了g1也就是f1 print('第二次f1'+s)
#往下继续走 print('第二次f2'+taibai)
##########结果
第一次f1alex
第一次f2taibai
第二次f1alex
第二次f2taibai
回调函数
#######回调函数
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def f1(n,s):
return n+s
def f2(n):
print('回调函数>>',n.result())
if __name__ == '__main__':
tp=ThreadPoolExecutor(4)
res=tp.submit(f1,11,12).add_done_callback(f2)
#####################
回调函数>> 23