python concurrent.futures ThreadPoolExecutor

concurrent.futures

提供ThreadPoolExecutor(线程池)和ProcessPoolExecutor(进程池)

# 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。
# 当一个线程完成的时候，主线程能够立即知道
# 让多线程和多进程的编码接口一致。

from concurrent.futures import ThreadPoolExecutor, wait, FIRST_COMPLETED, as_completed
from concurrent.futures import ProcessPoolExecutor
import time

def test(n):
    for i in range(n):
        print(i)
        time.sleep(1)
    return n

with ThreadPoolExecutor(max_workers=5) as t:    # 创建一个最大容纳数量为5的线程池
    task1 = t.submit(test, 4)   # 启动线程 
    task2 = t.submit(test, 3)
    
    print(task1.done())  # 查看线程是否已经结束
    time.sleep(5)
    print(task2.result()) # 查看线程的返回值
   
    

00

False
1
1
2
2
3
3

 # wait(fs,timeout, retuen_when)  fs表示需要执行的序列 timeout表示等待的最大时间,超出时间会中断为执行完的进程 return_when返回结果的条件
with ThreadPoolExecutor(max_workers=5) as t:
    all_task = [t.submit(test, i) for i in range(5)]
    wait(all_task,  return_when=FIRST_COMPLETED)
    print('4')

0
0
0
0
4
11
1

22

3

# 判断任务是否结束
with ThreadPoolExecutor(max_workers=5) as t:
    all_task = [t.submit(test, i) for i in range(5)]
    
    for task in as_completed(all_task):
        data = task.result()

00

0
0
11

1
22

3

# map用法  map(fn, *iterables, timeout=None, chunksize=1) fn表示需要线程执行的函数， iterable表示传入可迭代的参数  timeout超时 如果设置量小于函数执行时间则返回TimeoutError
# chunksize 表示将iterable分成chunksize任务块进行工作  只对进程池有效 线程池无效
executor = ThreadPoolExecutor(max_workers=5)
# executor.shutdown()
result = executor.map(test, [4,])
print('asd')
# print(result)
executor.shutdown()

0
asd
Object `executor.shutdown()` not found.
1
2
3

from concurrent.futures import ProcessPoolExecutor

threading 线程

import threading
import time

def test():
    time.sleep(3)
    print('done')

# Thread(group=None, tartget=None,name=None, args=(), keargs={}, *, daemon=None)  daemon 表示是否等结束后 主线程才结束 为True表示主线程结束
# 子线程也会结束
a = threading.Thread(target=test)  # target传入目标程序
a.start()  # 启动线程
# a.isAlive()  # 确认线程的存货状态
a.is_alive()  # 确认线程是否还存在
# threading.current_thread() 回调正在运行的线程

a.join(timeout=1) # 提供线程阻塞 可添加时间 单位s
# a.isAlive()
a.is_alive()

True



done

# 自定义类继承Thread
class TestThread(threading.Thread):
    def __init__(self, name=None):
        threading.Thread.__init__(self,name=name)
    
    def run(self):
        
        for i in range(5):
            print(threading.current_thread().name, i)
            time.sleep(1)

thread = TestThread(name='test')
thread.start()

test 0
test 1
test 2
test 3
test 4

# 创建线程锁
lock = threading.lock()
lock.acquire()  # 上锁
lock.release()  # 解锁