Python 使用threading+Queue实现线程池示例

一、线程池

1、为什么需要使用线程池

1.1 创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率。

记创建线程消耗时间T1,执行任务消耗时间T2,销毁线程消耗时间T3,如果T1+T3>T2,那说明开启一个线程来执行这个任务太不划算了!在线程池缓存线程可用已有的闲置线程来执行新任务,避免了创建/销毁带来的系统开销。

1.2 线程并发数量过多,抢占系统资源从而导致阻塞。

线程能共享系统资源,如果同时执行的线程过多,就有可能导致系统资源不足而产生阻塞的情况。

1.3 对线程进行一些简单的管理。

比如:延时执行、定时循环执行的策略等,运用线程池都能进行很好的实现。

2、Python中建立线程池的方法

2.1 使用threadpool模块,这是个python的第三方模块,支持python2和python3

2.2 使用concurrent.futures模块,这个模块是python3中自带的模块,python2.7以上版本也可以安装使用

2.3 自己构建一个线程池

二、队列(queue)

Queue模块提供的队列(FIFO)适用于多线程编程,在生产者(producer)和消费者(consumer)之间线程安全(thread-safe)地传递消息或其它数据,因此多个线程可以共用同一个Queue实例。常用方法:

Queue.qsize():返回queue的大小。

Queue.empty():判断队列是否为空,通常不太靠谱。

Queue.full():判断是否满了。

Queue.put(item, block=True, timeout=None): 往队列里放数据。

Queue.put_nowait(item):往队列里存放元素,不等待

Queue.get(item, block=True, timeout=None): 从队列里取数据。

Queue.get_nowait(item):从队列里取元素,不等待

Queue.task_done():表示队列中某个元素是否的使用情况,使用结束会发送信息。

Queue.join():一直阻塞直到队列中的所有元素都执行完毕。

三、使用threading+Queue处理多任务

假设有十个任务需要处理,打算在后台开启五个线程,简化后的模型

import Queue
import threading
import time

queue = Queue.Queue()

class ThreadNum(threading.Thread):
  def __init__(self, queue):
    threading.Thread.__init__(self)
    self.queue = queue

  def run(self):
    while True:
      #消费者端,从队列中获取num
      num = self.queue.get()
      print("Retrieved", num)
      time.sleep(1)
      #在完成这项工作之后,使用 queue.task_done() 函数向任务已经完成的队列发送一个信号
      self.queue.task_done()

    print("Consumer Finished")

def main():
  #产生一个 threads pool, 并把消息传递给thread函数进行处理,这里开启10个并发
  for i in range(5):
    t = ThreadNum(queue)
    t.setDaemon(True)
    t.start()

  #往队列中填数据
  for num in range(10):
    queue.put(num)
    #wait on the queue until everything has been processed

  queue.join()

if __name__ == '__main__':
  main()
  time.sleep(500)

输出为:

('Retrieved', 0)
 ('Retrieved', 1)('Retrieved', 2)
('Retrieved', 3)
('Retrieved', 4)
('Retrieved', 5)('Retrieved', 6)
('Retrieved', 7)
('Retrieved', 8)
 ('Retrieved', 9)

具体工作步骤描述如下:

1、创建一个 Queue.Queue() 的实例,然后使用数据对它进行填充。

2、将经过填充数据的实例传递给线程类,后者是通过继承 threading.Thread 的方式创建的。

3、生成守护线程池。

4、每次从队列中取出一个项目,并使用该线程中的数据和 run 方法以执行相应的工作。

5、在完成这项工作之后,使用 queue.task_done() 函数向任务已经完成的队列发送一个信号。

6、对队列执行 join 操作,实际上意味着等到队列为空,再退出主程序。

在使用这个模式时需要注意一点:通过将守护线程设置为 true,程序运行完自动退出。好处是在退出之前,可以对队列执行 join 操作、或者等到队列为空。

注意运行main函数后继续执行time.sleep(500),可以观察到主线程未结束的情况下ThreadNum(queue)生成的线程还在运行。如果需要停止线程的话可以对以上代码加以修改。

import Queue
import threading
import time

queue = Queue.Queue()

class ThreadNum(threading.Thread):
  """没打印一个数字等待1秒,并发打印10个数字需要多少秒?"""
  def __init__(self, queue):
    threading.Thread.__init__(self)
    self.queue = queue

  def run(self):
    done = False
    while not done:
      #消费者端,从队列中获取num
      num = self.queue.get()
      if num is None:
        done = True
      else:
        print("Retrieved", num)
      time.sleep(1)
      #在完成这项工作之后,使用 queue.task_done() 函数向任务已经完成的队列发送一个信号
      self.queue.task_done()

    print("Consumer Finished")
def main():
  #产生一个 threads pool, 并把消息传递给thread函数进行处理,这里开启10个并发
  for i in range(5):
    t = ThreadNum(queue)
    t.setDaemon(True)
    t.start()

  #往队列中填错数据
  for num in range(10):
    queue.put(num)

  queue.join()
  time.sleep(100)
  for i in range(10):
    queue.put(None)
    print('None')
  time.sleep(200)

if __name__ == '__main__':
  start = time.time()
  main()
  print"Elapsed Time: %s" % (time.time() - start)

main函数执行完后队列向线程发送None消息,触发线程的停止标识,这样就可以动态管理线程池了。

以上这篇Python 使用threading+Queue实现线程池示例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Python线程池模块ThreadPoolExecutor用法分析

    本文实例讲述了Python线程池模块ThreadPoolExecutor用法.分享给大家供大家参考,具体如下: python3内置的有Threadingpool和ThreadPoolExecutor模块,两个都可以做线程池,当然ThreadPoolExecutor会更好用一些,而且也有ProcessPoolExecutor进程池模块,使用方法基本一致. 首先导入模块 from concurrent.futures import ThreadPoolExecutor 使用方法很简单,最常用的可能就

  • python线程池threadpool实现篇

    本文为大家分享了threadpool线程池中所有的操作,供大家参考,具体内容如下 首先介绍一下自己使用到的名词: 工作线程(worker):创建线程池时,按照指定的线程数量,创建工作线程,等待从任务队列中get任务: 任务(requests):即工作线程处理的任务,任务可能成千上万个,但是工作线程只有少数.任务通过          makeRequests来创建 任务队列(request_queue):存放任务的队列,使用了queue实现的.工作线程从任务队列中get任务进行处理: 任务处理函

  • Django异步任务线程池实现原理

    这篇文章主要介绍了Django异步任务线程池实现原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 当数据库数据量很大时(百万级),许多批量数据修改请求的响应会非常慢,一些不需要即时响应的任务可以放到后台的异步线程中完成,发起异步任务的请求就可以立即响应 选择用线程池的原因是:线程比进程更为可控.不像子进程,子线程会在所属进程结束时立即结束.线程可共享内存. 请求任务异步处理的原理 使用python manage.py runserver模式启

  • python队列Queue的详解

    Queue Queue是python标准库中的线程安全的队列(FIFO)实现,提供了一个适用于多线程编程的先进先出的数据结构,即队列,用来在生产者和消费者线程之间的信息传递 基本FIFO队列 class Queue.Queue(maxsize=0) FIFO即First in First Out,先进先出.Queue提供了一个基本的FIFO容器,使用方法很简单,maxsize是个整数,指明了队列中能存放的数据个数的上限.一旦达到上限,插入会导致阻塞,直到队列中的数据被消费掉.如果maxsize小

  • python队列queue模块详解

    队列queue 多应用在多线程应用中,多线程访问共享变量.对于多线程而言,访问共享变量时,队列queue是线程安全的.从queue队列的具体实现中,可以看出queue使用了1个线程互斥锁(pthread.Lock()),以及3个条件标量(pthread.condition()),来保证了线程安全. queue队列的互斥锁和条件变量,可以参考另一篇文章:python线程中同步锁 queue的用法如下: import Queque a=[1,2,3] device_que=Queque.queue(

  • Python 使用threading+Queue实现线程池示例

    一.线程池 1.为什么需要使用线程池 1.1 创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率. 记创建线程消耗时间T1,执行任务消耗时间T2,销毁线程消耗时间T3,如果T1+T3>T2,那说明开启一个线程来执行这个任务太不划算了!在线程池缓存线程可用已有的闲置线程来执行新任务,避免了创建/销毁带来的系统开销. 1.2 线程并发数量过多,抢占系统资源从而导致阻塞. 线程能共享系统资源,如果同时执行的线程过多,就有可能导致系统资源不足而产生阻塞的情况. 1.3 对线

  • Python异步爬虫多线程与线程池示例详解

    目录 背景 异步爬虫方式 多线程,多进程(不建议) 线程池,进程池(适当使用) 单线程+异步协程(推荐) 多线程 线程池 背景 当对多个url发送请求时,只有请求完第一个url才会接着请求第二个url(requests是一个阻塞的操作),存在等待的时间,这样效率是很低的.那我们能不能在发送请求等待的时候,为其单独开启进程或者线程,继续请求下一个url,执行并行请求 异步爬虫方式 多线程,多进程(不建议) 好处:可以为相关阻塞的操作单独开启线程或者进程,阻塞操作就可以异步会执行 弊端:不能无限制开

  • Python探索之自定义实现线程池

    为什么需要线程池呢? 设想一下,如果我们使用有任务就开启一个子线程处理,处理完成后,销毁子线程或等得子线程自然死亡,那么如果我们的任务所需时间比较短,但是任务数量比较多,那么更多的时间是花在线程的创建和结束上面,效率肯定就低了.     线程池的原理: 既然是线程池(Thread pool),其实名字很形象,就是把指定数量的可用子线程放进一个"池里",有任务时取出一个线程执行,任务执行完后,并不立即销毁线程,而是放进线程池中,等待接收下一个任务.这样内存和cpu的开销也比较小,并且我们

  • Python中threading库实现线程锁与释放锁

    控制资源访问 前文提到threading库在多线程时,对同一资源的访问容易导致破坏与丢失数据.为了保证安全的访问一个资源对象,我们需要创建锁. 示例如下: import threading import time class AddThread(): def __init__(self, start=0): self.lock = threading.Lock() self.value = start def increment(self): print("Wait Lock") se

  • 在python中实现强制关闭线程的示例

    如下所示: import threading import time import inspect import ctypes def _async_raise(tid, exctype): """raises the exception, performs cleanup if needed""" tid = ctypes.c_long(tid) if not inspect.isclass(exctype): exctype = type(e

  • Python多线程Threading、子线程与守护线程实例详解

    本文实例讲述了Python多线程Threading.子线程与守护线程.分享给大家供大家参考,具体如下: 线程与进程: 线程对于进程来说,就好似工厂里的工人,分配资源是分配到工厂,工人再去处理. 线程是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源. 在单个程序中同时运行多个线程完成不同的工作,称为多线程 对于IO密集型的程序来说,多线程可以利用读IO的时间去做其他事[IO并不占用CPU,这就好像A

  • python中threading开启关闭线程操作

    在python中启动和关闭线程: 首先导入threading import threading 然后定义一个方法 def serial_read(): ... ... 然后定义线程,target指向要执行的方法 myThread = threading.Thread(target=serial_read) 启动它 myThread.start() 二.停止线程 不多说了直接上代码 import inspect import ctypes def _async_raise(tid, exctype

  • java中常见的6种线程池示例详解

    之前我们介绍了线程池的四种拒绝策略,了解了线程池参数的含义,那么今天我们来聊聊Java 中常见的几种线程池,以及在jdk7 加入的 ForkJoin 新型线程池 首先我们列出Java 中的六种线程池如下 线程池名称 描述 FixedThreadPool 核心线程数与最大线程数相同 SingleThreadExecutor 一个线程的线程池 CachedThreadPool 核心线程为0,最大线程数为Integer. MAX_VALUE ScheduledThreadPool 指定核心线程数的定时

  • DUCC配置平台实现一个动态化线程池示例代码

    目录 1.背景 2.代码实现 3.动态线程池应用 4.小结 作者:京东零售 张宾 1.背景 在后台开发中,会经常用到线程池技术,对于线程池核心参数的配置很大程度上依靠经验.然而,由于系统运行过程中存在的不确定性,我们很难一劳永逸地规划一个合理的线程池参数.在对线程池配置参数进行调整时,一般需要对服务进行重启,这样修改的成本就会偏高.一种解决办法就是,将线程池的配置放到配置平台侧,系统运行期间开发人员根据系统运行情况对核心参数进行动态配置. 本文以公司DUCC配置平台作为服务配置中心,以修改线程池

  • 用Python实现一个简单的线程池

    线程池的概念是什么? 在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源.在Java中更是 如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收.所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些 很耗资源的对象创建和销毁.如何利用已有对象来服务就是一个需要解决的关键问题,其实这就是一些"池化资源"技术产生的原因. 我理解为线程池是一个存放很多线程的单位,同时还有一个对应的任务队列.整个执行过程其实就是使

随机推荐