多线程编程

Python 主要提供了包括thread、threading、Queue等多线程编程模块。thread 模块提供了基本的线程和锁的支持，而threading提供了更高级别、功能更强的线程管理的功能。Queue模块允许用户创建一个可以用于多个线程之间共享数据的队列数据结构。

threading模块相对于thread模块对线程的支持更完善，除非是需要访问线程的底层结构，否则建议直接使用threading模块。

threading模块主要使用Thead类来创建线程，主要用以下三种使用方式：

使用函数来构造Thread类实例
使用可调用的类对象来构造Thread类实例
使用子类继承Thread类，然后重新Thread.run() 函数

使用函数来构造Thread类实例

# !/usr/bin/env python
import threading
from time import sleep

def loop(nloop, nsec):
  sleep(nsec)

def main():
  for i in xrange(5):
    t = threading.Thread(target=loop, args=(i, i))
    t.start()

使用可调用的类对象来构造Thread类实例

# !/usr/bin/env python
import threading
from time import sleep

def loop(nloop, nsec):
  sleep(nsec)

def ThreadFunc(object):
  def __init__(self, func, args, name=''):
    self.name = name
    self.func = func
    self.args = args
  
  def __call__(self):
    apply(self.func, self.args)

def main():
  for i in xrange(5):
    t = threading.Thread(target=ThreadFunc(loop, (i, i), loop.__name__))
    t.start()

使用子类继承Thread类

# !/usr/bin/env python
import threading
from time import sleep

def MyThread(threading.Thread):
  def __init__(self, func, args, name=''):
    self.name = name
    self.func = func
    self.args = args
  
  def run(self):
    apply(self.func, self.args)

def main():
  for i in xrange(5):
    t = MyThread(loop, (i, i), loop.__name__)
    t.start()

多线程编程的不足

Python 代码的执行由Python虚拟机（也叫解释器主循环）来控制。为了解决多线程之间数据完整性和状态同步的问题，设计为在任意时刻只有一个线程在解释器中运行。对Python虚拟机的访问由全局解释器锁（GIL， global interpreter lock）来控制，正是这个锁能保证同一时刻只有一个线程执行。

即Python中的多线程是表面多线程，也可以理解为fake多线程，不是真正的多线程。

Python中，如果想利用计算机的多核提高程序执行效率，用多进程代替多线程，也可以考虑把核心部分也成C模块，或者索性用其他语言实现。

多进程编程

python实现多进程的模块最常用的是multiprocessing、concurrent.futures，此外还有multiprocess、pathos、pp、parallel、pprocess等模块。本文主要介绍multiprocessing的使用方式。

multiprocessing支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。这里我们只是介绍一下Process组件.

Process组件

在multiprocessing中，每一个进程都用一个Process类来表示。

# 应始终使用关键字参数调用构造函数
class multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={})
- group：分组，应该始终是None ,它仅用于兼容threading.Thread
- target：表示调用对象，你可以传入方法的名字
- name：别名，相当于给这个进程取一个名字
- args：表示被调用对象的位置参数元组，比如target是函数a，他有两个参数m，n，那么args就传入(m, n)即可
- kwargs：表示调用对象的字典

一个简单的例子：

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

multiprocessing.Process 更多的方法见： https://docs.python.org/zh-cn/3.7/library/multiprocessing.html#multiprocessing.Process.run

进程池的使用

如果要启动大量的子进程，可以用进程池的方式批量创建子进程。

class multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])
- processes 是要使用的工作进程数目

multiprocessing.pool.Pool 常用方法有以下三个：

apply(func[, args[, kwds]])
  - 使用 args 参数以及 kwds 命名参数调用 func , 它会返回结果前阻塞。
apply_async(func[, args[, kwds[, callback[, error_callback]]]])
  - apply() 方法的一个变种，异步返回结果。
  - 如果指定了 callback , 它必须是一个接受单个参数的可调用对象。当执行成功时， callback 会被用于处理执行后的返回结果，否则，调用 error_callback 。
map(func, iterable[, chunksize])
  - 内置 map() 函数的并行版本
  - 这个方法会将可迭代对象分割为许多块，然后提交给进程池。可以将 chunksize 设置为一个正整数从而（近似）指定每个块的大小可以。

Pool.apply_async()异步执行返回的结果为 class multiprocessing.pool.AsyncResult, 主要用以下几个方法

get([timeout])
  - 用于获取执行结果。如果 timeout 不是 None 并且在 timeout 秒内仍然没有执行完得到结果，则抛出 multiprocessing.TimeoutError 异常
wait([timeout])
  - 阻塞，直到返回结果，或者 timeout 秒后超时。
ready()
  - 用于判断执行状态，是否已经完成。
successful()
  - 判断调用是否已经完成并且未引发异常。 如果还未获得结果则将引发 ValueError。

下面是一个简单的使用示例。

import random
from multiprocessing.pool import Pool
from time import sleep, time

import os


def run(name):
    print("%s子进程开始，进程ID：%d" % (name, os.getpid()))
    start = time()
    sleep_time = random.choice([1, 2, 3, 4])
    sleep(sleep_time)
    end = time()
    print("%s子进程结束，进程ID：%d。耗时0.2%f" % (name, os.getpid(), end-start))
    return sleep_time


if __name__ == "__main__":
    print("父进程开始")
    # 创建多个进程，表示可以同时执行的进程数量。默认大小是CPU的核心数
    p = Pool(8)
    result = []
    for i in range(10):
        # 创建进程，放入进程池统一管理
        result.append(p.apply_async(run, args=(i,)))
    for i in range(10):
        print i, 'sleep', result[i].get()
    # 如果我们用的是进程池，在调用join()之前必须要先close()，并且在close()之后不能再继续往进程池添加新的进程
    p.close()
    # 进程池对象调用join，会等待进程吃中所有的子进程结束完毕再去结束父进程
    p.join()
    print("父进程结束。")