多线程池以及futures python新的线程包

from concurrent.futures import ThreadPoolExecutor
import time

def sayh(pus):
    print("name: "+pus)
    time.sleep(2)

def main():
    put_list=["恩恩","嗯嗯","(⊙o⊙)嗯"]
    start1=time.time()
    for pus in put_list:
        sayhello(pus)
    end1=time.time()
    print("循环执行时间: "+str(end1-start1))

# concurrent.futures.ThreadPoolExecutor，在提交任务的时候，有两种方式，一种是submit（）函数，另一种是map（）函数，两者的主要区别在于：
#1、map可以保证输出的顺序, submit输出的顺序是乱的

    start2=time.time()
    with ThreadPoolExecutor(3) as executor:
        for pus in put_list:
            executor.submit(sayhello,pus)
    end2=time.time()
    print("submit执行的时间: "+str(end2-start2))

#2、如果你要提交的任务的函数是一样的，就可以简化成map。但是假如提交的任务函数是不一样的，或者执行的过程之可能出现异常（使用map执行过程中发现问题会直接抛出错误）就要用到submit（）

    start3=time.time()
    with ThreadPoolExecutor(3) as executor1:
        executor1.map(sayh,pus)
    end3=time.time()
    print("map执行的时间: "+str(end3-start3))

if __name__ == '__main__':
    main()

3、submit和map的参数是不同的，submit每次都需要提交一个目标函数和对应的参数，map只需要提交一次目标函数，目标函数的参数放在一个迭代器（列表，字典）里就可以。

 

多线程池思路：
    1.创建一个 Queue.Queue() 的实例，然后使用数据对它进行填充。
    2.将经过填充数据的实例传递给线程类，后者是通过继承 threading.Thread 的方式创建的。
    3.生成守护线程池。
    4.每次从队列中取出一个项目，并使用该线程中的数据和 run 方法以执行相应的工作。
    5.在完成这项工作之后，使用 queue.task_done() 函数向任务已经完成的队列发送一个信号。
    6.对队列执行 join 操作

import threading
import time
from queue import Queue


class WorkManager(object):
    def __init__(self, work_num,thread_num=2):
        self.work_queue = Queue()
        self.threads = []
        self.Initialize_the_work_queue(work_num)
        self.Initialize_the_thread_pool(thread_num)

    # 初始化线程
    def Initialize_the_thread_pool(self,thread_num):
        for i in range(thread_num):
    # 调用work类去初始话线程
            self.threads.append(InitializeThe(self.work_queue))

    # 初始化工作队列
    def Initialize_the_work_queue(self, jobs_num):
        for args in jobs_num:
            # args 任务的参数
            self.add_job(do_job, args)


    # 添加一项工作入队
    def add_job(self, func, *args):
        # 任务入队
        self.work_queue.put((func, args))


    # 等待所有线程运行完毕
    def wait_allcomplete(self):
        for item in self.threads:
            if item.isAlive(): # 判断线程是否属于存活状态
                item.join()

class InitializeThe(threading.Thread):
    def __init__(self, work_queue):
        threading.Thread.__init__(self)
        self.work_queue = work_queue
        self.start()

    def run(self):
        # 让创建的线程在一定条件下关闭退出
        while True:
            try:
                # 任务异步出队
                do, args = self.work_queue.get(block=False)
                do(args)
                self.work_queue.task_done()# 通知系统任务完成
            except:
                break

# 具体要做的任务
def do_job(args):
    # 模拟处理时间
    time.sleep(0.1)
    # 可以拿到参数 args=(1,)
    print(threading.current_thread(), args)

if __name__ == '__main__':

    work_num = [work_num for work_num in range(1,1000)]
    work_manager = WorkManager(work_num, 10)
    work_manager.wait_allcomplete()