python-day34(GIL锁,线程池)

一. GIL锁

　　GIL锁(Global Interpreter Lock),本质就是一把互斥锁

 

       >>>>>关于GIL锁<<<<<

二. 线程队列

　　queue队列:  使用import queue ,用法与进程Queue一样,队列都是安全的,不会出现多个线程

　　抢占同一个资源或数据的情况. 

import queue

# # 先进先出
q = queue.Queue(3)
q.put(1)
q.put(13)
q.put(2)
while 1:
    try:
        print(q.get_nowait())
    except:
        break
'''
结果:
1
13
2
'''

import queue
# 后进先出
q = queue.LifoQueue(3)
q.put((2,222))
q.put((1,111))
q.put((3,333))
print(q.get())
print(q.get())
print(q.get())
'''
结果:
(3, 333)
(1, 111)
(2, 222)
'''

import queue
# 排序 ASCII 码排序
q = queue.PriorityQueue(3)
q.put(333)
q.put(222)
q.put(111)
print(q.get())
print(q.get())
print(q.get())
print(q.get())
'''
结果:
111
222
333
'''

三. 线程池

　　concurrent.futures模块  使用threadPoolExecutor 和ProcessPoolExecutor的方式一样,

concurrent.futures模块提供了高度封装的异步调用接口
ThreadPoolExecutor：线程池，提供异步调用
ProcessPoolExecutor: 进程池，提供异步调用
Both implement the same interface, which is defined by the abstract Executor class.

#2 基本方法
#submit(fn, *args, **kwargs)
异步提交任务

#map(func, *iterables, timeout=None, chunksize=1) 
取代for循环submit的操作

#shutdown(wait=True) 
相当于进程池的pool.close()+pool.join()操作
wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False，立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值，整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前

#result(timeout=None)
取得结果

#add_done_callback(fn)
回调函数

import time
import os
import threading
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def func(n):
    time.sleep(2)
    print('%s打印的：'%(threading.get_ident()),n)
    return n*n
tpool = ThreadPoolExecutor(max_workers=5) #默认一般起线程的数据不超过CPU个数*5
# tpool = ProcessPoolExecutor(max_workers=5) #进程池的使用只需要将上面的ThreadPoolExecutor改为ProcessPoolExecutor就行了，其他都不用改
#异步执行
t_lst = []
for i in range(5):
    t = tpool.submit(func,i) #提交执行函数,返回一个结果对象，i作为任务函数的参数 def submit(self, fn, *args, **kwargs):  可以传任意形式的参数
    t_lst.append(t)  #
    # print(t.result())
    #这个返回的结果对象t，不能直接去拿结果，不然又变成串行了，可以理解为拿到一个号码，等所有线程的结果都出来之后，我们再去通过结果对象t获取结果
tpool.shutdown() #起到原来的close阻止新任务进来 + join的作用，等待所有的线程执行完毕
print('主线程')
for ti in t_lst:
    print('>>>>',ti.result())

# 我们还可以不用shutdown()，用下面这种方式
# while 1:
#     for n,ti in enumerate(t_lst):
#         print('>>>>', ti.result(),n)
#     time.sleep(2) #每个两秒去去一次结果，哪个有结果了，就可以取出哪一个，想表达的意思就是说不用等到所有的结果都出来再去取，可以轮询着去取结果,因为你的任务需要执行的时间很长，那么你需要等很久才能拿到结果，通过这样的方式可以将快速出来的结果先拿出来。如果有的结果对象里面还没有执行结果，那么你什么也取不到，这一点要注意，不是空的，是什么也取不到,那怎么判断我已经取出了哪一个的结果，可以通过枚举enumerate来搞，记录你是哪一个位置的结果对象的结果已经被取过了，取过的就不再取了

#结果分析： 打印的结果是没有顺序的，因为到了func函数中的sleep的时候线程会切换，谁先打印就没准儿了，但是最后的我们通过结果对象取结果的时候拿到的是有序的，因为我们主线程进行for循环的时候，我们是按顺序将结果对象添加到列表中的。
# 37220打印的： 0
# 32292打印的： 4
# 33444打印的： 1
# 30068打印的： 2
# 29884打印的： 3
# 主线程
# >>>> 0
# >>>> 1
# >>>> 4
# >>>> 9
# >>>> 16

　　ProcessPoolExecutor的使用:

只需要将这一行代码改为下面这一行就可以了，其他的代码都不用变
tpool = ThreadPoolExecutor(max_workers=5) #默认一般起线程的数据不超过CPU个数*5
# tpool = ProcessPoolExecutor(max_workers=5)

你就会发现为什么将线程池和进程池都放到这一个模块里面了，用法一样

　　map的使用

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from multiprocessing import Pool

def fun(n):
    time.sleep(1)
    print(n)
    return n**2
if __name__ == '__main__':
    t_p = ThreadPoolExecutor(4)
    # t_p = ProcessPoolExecutor(4)
    p_pool = Pool(4)
    res_lst = []

    # res = t_p.map(fun ,range(10))
    #
    # print(res)
    # t_p.shutdown()
    # print('主线程结束')
    # for i in res:
    #     print(i)
# ------------------------------------/
#     for i in range(10):
#         res = t_p.submit(fun,i)
#         res_lst.append(res)
#     t_p.shutdown()
# 
#     for i in res_lst:
#         print(i.result())
# ---------------------------------------
    # for i in range(10):
    #     res = p_pool.apply_async(fun,(i,))
    #     res_lst.append(res)
    #     print(res.get())
    # p_pool.close()
    # p_pool.join()
    # for i in res_lst:
    #     print(i.get())

四. 线程池的回调函数

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from multiprocessing import Pool

def fun(n):
    time.sleep(1)
    return n*n
def call_bcak(m):
    print('结果为: %s' %m.result())

def c_back(m):
    print('结果为: %s' %m)
if __name__ == '__main__':
    p = Pool(4)

    # t_p = ThreadPoolExecutor(4)
    # lst = []
    # for i in range(10):
    #     res = t_p.submit(fun,i)
    #     lst.append(res)
    # t_p.shutdown()
    # for i in lst:
    #     i.add_done_callback(call_bcak)
# -----------------------------------------------------
#     lst = []
#     for i in range(10):
#         res = p.apply_async(fun,args=(i,),callback=c_back)
#         # print(res.get())
#     p.close()
#     p.join()

 >>>>>>>>>更多点击