python多线程抽象编程模型详解

最近需要完成一个多线程下载的工具，对其中的多线程下载进行了一个抽象，可以对所有需要使用到多线程编程的地方统一使用这个模型来进行编写。

主要结构：

1、基于queue标准库实现了一个类似线程池的工具，用户指定提交任务线程submitter与工作线程worker数目，所有线程分别设置为后台运行，提供等待线程运行完成的接口。

2、所有需要完成的任务抽象成task，提供单独的无参数调用方式，供worker线程调用；task以生成器的方式作为参数提供，供submitter调用。

3、所有需要进行线程交互的信息放在context类中。

主要实现代码如下:

#submitter线程类实现，主要是`task_generator`调用
class submitterthread(threading.thread):
  _default_wait_timeout = 2 #seconds
  def __init__(self, queue, task_gen, timeout=2):
    super(submitterthread, self).__init__()
    self.queue = queue
    if not isinstance(timeout, int):
      _logger.error('thread wait timeout value error: %s, '
             'use default instead.' % timeout)
      self.timeout = self._default_wait_timeout
    self.timeout = timeout
    self.task_generator = task_gen

  def run(self):
    while true:
      try:
        task = self.task_generator.next()
        self.queue.put(task, true, self.timeout)
      except queue.full:
        _logger.debug('task queue is full. %s wait %d second%s timeout' %
               (self.name, self.timeout, 's' if (self.timeout > 1) else ''))
        break
      except (stopiteration, valueerror) as e:
        _logger.debug('task finished')
        break

#worker线程实现，主要就是try块内的func调用
class workerthread(threading.thread):
  _default_wait_timeout = 2 #seconds
  def __init__(self, queue, timeout=2):
    super(workerthread, self).__init__()
    self.queue = queue
    if not isinstance(timeout, int):
      _logger.error('thread wait timeout value error: %s, '
             'use default instead.' % timeout)
      self.timeout = self._default_wait_timeout
    self.timeout = timeout

  def run(self):
    while true:
      try:
        func = self.queue.get(true, self.timeout)
      except queue.empty:
        _logger.debug('task queue is empty. %s wait %d second%s timeout' %
               (self.name, self.timeout, 's' if (self.timeout > 1) else ''))
        break

      if not callable(func):
        time.sleep(1)
      try:
        func()
      except exception as e:
        _logger.error('thread %s running occurs error: %s' %
               (self.name, e))
        print('thread running error: %s' % e)

class executor(object):
  """
  the really place to execute executor
  """
  thread_list = []
  submitters = 0
  workers = 0
  queue = none
  task_generator = none
  timeout = 0
  def __init__(self, task_gen, submitters=1, workers=1 , timeout=2):
    if len(self.thread_list) != 0:
      raise runtimeerror('executor can only instance once.')
    self.queue = queue.queue(maxsize=submitters * 2 + workers * 2)
    self.submitters = submitters
    self.workers = workers
    self.task_generator = task_gen
    self.timeout = timeout

  def start(self):
    for i in range(self.submitters):
      submitter = submitterthread(self.queue, self.task_generator, self.timeout)
      self.thread_list.append(submitter)
      submitter.setname('submitter-%d' % i)
      submitter.setdaemon(true)
      submitter.start()
    for i in range(self.workers):
      worker = workerthread(self.queue, self.timeout)
      self.thread_list.append(worker)
      worker.setname('worker-%d' % i)
      worker.setdaemon(true)
      worker.start()

  def is_alive(self):
    alive = false
    for t in self.thread_list:
      if t.isalive():
        alive = true
        break
    return alive

  def wait_to_shutdown(self):
    _logger.debug('start to wait to shutdown')
    for t in self.thread_list:
      t.join()
      _logger.debug('shutdown thread : %s' % t.name)

executor类保存了线程池，提供相应接口。有了这个抽象之后，只需要实例化executor类的对象，然后调用start方法进行多线程任务的运行。并可以用is_alive等接口再主线程内进行其他处理。

后续再使用这个抽象进行实际多线程任务的实现。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。