python线程池

为什么需要线程池 　　目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。 　　传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出，这就是是“ 即时创建， 即时销毁 ”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是 如果提交给线程的任务是执行时间较短，而且执行次数极其频繁，那么服务器将处于不停的创建线程，销毁线程的状态 。 　　我们将传统方案中的线程执行过程分为三个过程：T1、T2、T3： 　　T1：线程创建时间 　　T2：线程执行时间，包括线程的同步等时间 　　T3：线程销毁时间 　　那么我们可以看出，线程本身的开销所占的比例为(T1+T3) / (T1+T2+T3)。如果线程执行的时间很短的话，这比开销可能占到20%-50%左右。如果任务执行时间很频繁的话，这笔开销将是不可忽略的。 　　除此之外，线程池能够减少创建的线程个数。通常线程池所允许的并发线程是有上界的，如果同时需要并发的线程数超过上界，那么一部分线程将会等待。而传统方案中，如果同时请求数目为2000，那么最坏情况下，系统可能需要产生2000个线程。 尽管这不是一个很大的数目，但是也有部分机器可能达不到这种要求。 　　

版本一： #!/usr/bin/env python # -*- coding:utf-8 -*- import Queue import threading class ThreadPool(object): def __init__(self, max_num=20): self.queue = Queue.Queue(max_num) for i in xrange(max_num): self.queue.put(threading.Thread) def get_thread(self): return self.queue.get() def add_thread(self): self.queue.put(threading.Thread) """ pool = ThreadPool(10) def func(arg, p): print arg import time time.sleep(2) p.add_thread() for i in xrange(30): thread = pool.get_thread() t = thread(target=func, args=(i, pool)) t.start() """ 版本二： #!/usr/bin/env python # -*- coding:utf-8 -*- """ custom ThreadPool

1 import time 2 from concurrent.futures import ThreadPoolExecutor 3 4 def RunBenchmark(url): 5 print('GET %s' % url) 6 response = url 7 time.sleep(3) 8 return(url+" FINISHED") 9 10 def RunPool(): 11 urls = 'CPU' 12 pool = ThreadPoolExecutor(1)　　　　　　　　　 #启动一个线程池 13 task=pool.submit(RunBenchmark, urls)　　　　　#在另外的线程中运行RunBenchmark()　 14 while(not task.done()):　　　　　　　　　　　　　#task.done()表示线程池中的工作完成了 15 print("ooo")　　　　　　　　　　　　　　　　　#主线程中可以执行其他工作 16 time.sleep(0.5) 17 print("bye") 18 19 if __name__ == '__main__': 20 RunPool() https://www.jianshu.com/p/b9b3d66aa0be https://blog.csdn.net/sinat_34461756

线程池&进程池 在python2中没有提供，在python3之后才提供 作用：保证程序中最多可以创建的线程的个数 import time from concurrent.futures import ThreadPoolExecutordef task(n1,n2): time.sleep(1) print('星空不问赶路人')pool = ThreadPoolExecutor(10) # 创建线程池for i in range(100): pool.submit(task,i,1)pool.shutdown(True) # 等线程池中任务执行完毕之后，再继续往后走print('岁月不负有心人') import time from concurrent.futures import ThreadPoolExecutordef task(arg): time.sleep(1) print('星空不问赶路人') return '岁月不负有心人'ret = pool.map(task,range(1,20)) # 具有返回值print('end',ret)pool.shutdwon(True)for i in ret: print(i) # 直接输出i import timefrom concurrent.futures import ThreadPoolExecutordef task

8.6 GIL锁** Global interpreter Lock 全局解释器锁 实际就是一把解释器级的互斥锁 In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.) 大意：在CPython解释器中，同一个进程下如果有多个线程同时启动，那么CPython一次只允许一个线程执行，这种规则由GIL完成 需要明确的事情是：GIL不是python的特性，而是 CPython解释器的特性 这里有篇文章，感觉写的不错 8.6.1 GIL的介绍 ​ 既然上文提到了GIL是一把互斥锁，所以它也是满足互斥锁的一些特性，是将并发运行变成串行，一次来保证在同一时间内公共数据只能被一个任务修改

import time from multiprocessing.pool import ThreadPool #注意ThreadPool不在threading模块下 from multiprocessing import Pool #导入进程池 def my_print(i): print("task start {}".format(i)) time.sleep(4) print("task end {}".format(i)) if __name__ == '__main__': tp = ThreadPool(10) # tp = Pool(10) for i in range(10): tp.apply_async(my_print,args=(i,)) tp.close() tp.join() 来源： CSDN 作者： ITROOKIEIS 链接： https://blog.csdn.net/qq_15256443/article/details/103634256

线程池的两张方法 submit 和map from concurrent.futures import ThreadPoolExecutor import time # def sayhello(a): time.sleep(2) return "hello: "+a def main(): seed = ["a","b","c"] # 不使用线程 start1 = time.time() for each in seed: t1 = sayhello(each) print(t1) end1 = time.time() print("time1: "+str(end1-start1)) print('------------------submit----------------------') # 线程池submit用法 # 1.先把值存放在列表中 # 2.在遍历列表取返回值 # 3.将遍历获取的结果存放在列表中 start2 = time.time() lst = [] result_lst = [] with ThreadPoolExecutor(3) as executor: for each in seed: t2 = executor.submit(sayhello, each) lst.append(t2) for i in lst: print(i.result(

适用于有大量的事件，每个事件的执行时间不长的情况 创建进程池，放入适当的进程 from multiprocessing import Pool Pool(processes) 功能：创建进程池对象 参数：指定进程数量，默认根据系统自动判定 将事件加入进程池队列执行 pool.apply_async(func,args,kwds) 功能：使用进程池执行 func事件 参数： func 事件函数 args 元组 给func按位置传参 kwds 字典 给func按照键值传参 返回值：返回函数事件对象 关闭进程池 pool.close() 回收进程池中进程 pool.join() 功能：回收进程池中进程 from multiprocessing import Pool from time import sleep , ctime #进程池执行事件 def worker ( msg ) : sleep ( 2 ) print ( ctime , '--' , msg ) #创建进程池,默认个数。创建进程池时进程就生成了 pool = Pool ( ) #添加进程事件 for i in range ( 10 ) : #向队列中放入10个事件 msg = 'Tedu %d' % i #将事件加入进程池队列中，func绑定进程事件函数，arg是个元组 pool . apply_async (

使用with方式创建线程池，任务执行完毕之后，会自动关闭资源 ， 否则就需要手动关闭线程池资源 import threading, time from concurrent.futures import ThreadPoolExecutor, as_completed class MyTask(threading.Thread): """ 使用python线程的方法 """ def __init__(self, thread_id): threading.Thread.__init__(self) self.thread_id = thread_id def run(self): while 1: print('%s线程正在运行。。。。。。。。' % self.thread_id) time.sleep(1) class MyThreadPool(object): """ 使用python线程池的两种方式 """ def __init__(self): """init方法，构造测试数据""" self.param_data = [] for i in range(1000): self.param_data.append(str(i)) def target_task(self, param): """目标方法""" print(threading.currentThread()

一、线程池 实例： 1 import threadpool 2 import requests,time,threading 3 from hashlib import md5 4 def down_load_pic(url): 5 req = requests.get(url) 6 m = md5(url.encode()) 7 with open( m.hexdigest()+'.png','wb') as fw: 8 fw.write(req.content) 9 10 url_list = ['http://www.nnzhp.cn/wp-content/uploads/2019/10/f410afea8b23fa401505a1449a41a133.png', 11 'http://www.nnzhp.cn/wp-content/uploads/2019/11/481b5135e75c764b32b224c5650a8df5.png', 12 'http://www.nnzhp.cn/wp-content/uploads/2019/11/b23755cdea210cfec903333c5cce6895.png', 13 'http://www.nnzhp.cn/wp-content/uploads/2019/11