44.python之线程池

线程池

• 普通多线程方案会使用“即时创建，即时销毁”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数极其频繁，那么服务器将处于不停的创建线程，销毁线程的状态。
• 一个线程的运行时间可以分为3部分：线程的启动时间、线程体的运行时间和线程的销毁时间。在多线程处理的情景中，如果线程不能被重用，就意味着每次创建都需要经过启动、销毁和运行3个过程。这必然会增加系统相应的时间，降低了效率。
• 使用线程池，线程预先被创建并放入线程池中，同时处理完当前任务之后并不销毁而是被安排处理下一个任务，因此能够避免多次创建线程，从而节省线程创建和销毁的开销，能带来更好的性能和系统稳定性。
• 当有任务时，会先判断线程池中是否有空闲的线程（即没有执行任务的线程），若是有，任务会找到空闲线程开始执行；若是没有，线程会在线程池门口等待直到有空闲线程，然后再进入线程池找到线程开始执行。

创建线程池：Python内置包concurrent

用法：

from concurrent.futures import ThreadPoolExecutor

tpool=ThreadPoolExecutor(max_workers)

参数：

• max_workers：线程池中线程数量
• 使用result，可以获取函数的返回值

线程池常用方法

例1：创建线程池

import threading
import time
from concurrent.futures import ThreadPoolExecutor

def test(count):
    print(f'count={count},线程名称是：{threading.current_thread().name}')
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)
    # 往线程池中添加任务
    for i in range(6):
        data = t.submit(test, i)

结果：

• 可以看到有2个进程在执行任务
• 2句打印在一行是因为这2个线程是同时执行的
  

例2：取消任务cancel和判断是否完成任务

import threading
import time
from concurrent.futures import ThreadPoolExecutor

def test(count):
    print(f'count={count},进程名称是：{threading.current_thread().name}')
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)
    
    for i in range(6):
        # 往线程池中添加任务
        data = t.submit(test, i)

        # 符合条件的，取消任务，但是要注意已经开始执行的任务是取消不了的
        if i in (1, 5):
            data.cancel()
        else:
            # 获取函数返回值
            print(f'data={data.result()},是否完成任务：{data.done()}')

结果：

• 结果中没有执行1和5的任务
  

wait方法

等待线程池中的任务执行完后再执行其他线程

用法：

wait(fs, timeout=None, return_when=ALL_COMPLETED)

参数：

• fs：表示需要执行的序列
• timeout：等待的最大时间，如果超过这个时间即使线程未执行完成也将返回
• return_when：表示wait返回结果的条件，默认为 ALL_COMPLETED 全部执行完成再返回，FIRST_COMPLETED表示完成第一个任务后就执行主线程

例1：使用ALL_COMPLETED，所有任务都完成后再执行主线程

import threading
import time
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import wait, ALL_COMPLETED

def test(count):
    print(f'count={count},线程名称是：{threading.current_thread().name}')
    time.sleep(1)
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)

    # 往线程池中添加任务
    task = [t.submit(test, i) for i in range(4)]

    # 等待线程池中任务执行完后再执行主线程
    wait(task, return_when=ALL_COMPLETED)

    print(f'时间间隔是：{time.time()-start_time},当前线程名称是：{threading.current_thread().name}')

结果：

例2：第一个任务完成后执行主线程

import threading
import time
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import wait, FIRST_COMPLETED

def test(count):
    print(f'count={count},线程名称是：{threading.current_thread().name}')
    time.sleep(1)
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)

    # 往线程池中添加任务
    task = [t.submit(test, i) for i in range(4)]

    # 等待线程池中任务执行完后再执行主线程
    wait(task, return_when=FIRST_COMPLETED)

    print(f'时间间隔是：{time.time()-start_time},当前线程名称是：{threading.current_thread().name}')

结果：

• 主线程执行完的时间间隔是1s
• 这里打印时间间隔的语句不一定是在最后一行，她跟count=2和3应该是同时间执行的，所以还有可能在它们前面或者中间或者同一行，
• 执行几次就可以看出来了

as_completed方法

任务未完成时，会阻塞，某个任务完成的时候，会 yield这个任务，出现空闲线程，for循环下面的语句，然后继续阻塞住，循环到所有的任务结束。
先完成的任务会先通知主线程

例：

import threading
import time
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import as_completed

def test(count):
    print(f'count={count},线程名称是：{threading.current_thread().name}')
    time.sleep(1)
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)

    # 往线程池中添加任务
    task = [t.submit(test, i) for i in range(4)]

    # 等待线程池中任务执行完后再执行主线程
    for i in as_completed(task):
        data = i.result()
        print(f'data={data},当前线程名称是：{threading.current_thread().name}')

    print(f'时间间隔是：{time.time()-start_time},当前线程名称是：{threading.current_thread().name}')

结果：

map方法

使用 map 方法，无需提前使用 submit 方法，map 方法与 python 高阶函数 map 的含义相同，都是将序列中的每个元素都执行同一个函数。
上面的代码对列表中的每个元素都执行 spider() 函数，并分配各线程池。

用法：

map(fn, *iterables, timeout=None)

参数：

• fn： 表示需要线程执行的函数；
• iterables：表示接受一个可迭代对象；
• timeout：与wait() 的 timeout 一样，但由于 map 是返回线程执行的结果，如果 timeout小于线程执行时间会抛异常 TimeoutError

例：

import threading
import time
from concurrent.futures import ThreadPoolExecutor

def test(count):
    print(f'count={count},线程名称是：{threading.current_thread().name}')
    time.sleep(1)
    return count

if __name__ == '__main__':
    start_time = time.time()

    # 创建线程池,里面有2个线程
    t = ThreadPoolExecutor(2)
    for data in t.map(test, range(4)):
        print(f'data={data}')

结果：

• data输出顺序和任务执行顺序相同，就算是任务已完成也还是会优先打印前面还未打印的data