一、多进程
1. 进程池
由于Python中线程封锁机制，导致Python中的多线程并不是正真意义上的多线程。当我们有并行处理需求的时候，可以采用多进程迂回地解决。
如果要在主进程中启动大量的子进程，可以用进程池的方式批量创建子进程。
首先，创建一个进程池子，然后使用 apply_async() 方法将子进程加入到进程池中。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time : 2018/5/23 14:15
# @Author : zhouyuyao
# @File : demon1.py
import multiprocessing
import os
import time
from datetime import datetime
def subprocess(number):
# 子进程
print('这是第{0}个子进程'.format(number))
pid = os.getpid() # 得到当前进程号
print('当前进程号：{0}，开始时间：{1}'.format(pid, datetime.now().isoformat()))
time.sleep(30) # 当前进程休眠30秒
print('当前进程号：{0}，结束时间：{1}'.format(pid, datetime.now().isoformat()))
def mainprocess():
# 主进程
print('这是主进程，进程编号：{0}'.format(os.getpid()))
t_start = datetime.now()
pool = multiprocessing.Pool()
for i in range(8):
pool.apply_async(subprocess, args=(i,))
'''pool.apply_async 非阻塞，定义的进程池最大数的同时执行
pool.apply 一个进程结束，释放回进程池，开始下一个进程
pool.apply_async()维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去'''
pool.close()
'''Prevents any more tasks from being submitted to the pool.
Once all the tasks have been completed the worker processes will exit.'''
pool.join()
'''Wait for the worker processes to exit.
One must call close() or terminate() before using join().'''
t_end = datetime.now()
print('主进程用时：{0}毫秒'.format((t_end - t_start).microseconds))
if __name__ == '__main__':
# 主测试函数，当模块被直接运行时，以下代码块将被运行，当模块是被导入时，代码块不被运行
mainprocess()我们创建了7个子进程，它们的运行状况如下
这是主进程，进程编号：10616
这是第0个子进程
当前进程号：17464，开始时间：2018-05-23T21:22:25.986975
这是第1个子进程
当前进程号：11348，开始时间：2018-05-23T21:22:25.990986
这是第2个子进程
当前进程号：4732，开始时间：2018-05-23T21:22:25.997503
这是第3个子进程
当前进程号：12196，开始时间：2018-05-23T21:22:26.002516
当前进程号：17464，结束时间：2018-05-23T21:22:55.987520
这是第4个子进程
当前进程号：17464，开始时间：2018-05-23T21:22:55.987520
当前进程号：11348，结束时间：2018-05-23T21:22:55.991028
这是第5个子进程
当前进程号：11348，开始时间：2018-05-23T21:22:55.991028
当前进程号：4732，结束时间：2018-05-23T21:22:55.998090
这是第6个子进程
当前进程号：4732，开始时间：2018-05-23T21:22:55.998090
当前进程号：12196，结束时间：2018-05-23T21:22:56.002560
这是第7个子进程
当前进程号：12196，开始时间：2018-05-23T21:22:56.002560
当前进程号：17464，结束时间：2018-05-23T21:23:25.988243
当前进程号：11348，结束时间：2018-05-23T21:23:25.991248
当前进程号：4732，结束时间：2018-05-23T21:23:25.998248
当前进程号：12196，结束时间：2018-05-23T21:23:26.003260
主进程用时：925895毫秒二、多线程
多线程类似于同时执行多个不同程序，多线程运行有如下优点：
- 使用线程可以把占据长时间的程序中的任务放到后台去处理。
- 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
- 程序的运行速度可能加快
- 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
- 线程可以被抢占（中断）。
- 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。
线程可以分为:
- 内核线程：由操作系统内核创建和撤销。
- 用户线程：不需要内核支持而在用户程序中实现的线程。
Python3 线程中常用的两个模块为：
- _thread
- threading(推荐使用)
thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 "_thread"。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。
Python中使用线程有两种方式：函数或者用类来包装线程对象。
1. 函数式
启动一个线程就是把一个函数传入并创建 Thread 实例，然后调用 start() 开始执行：
threading.Thread(self, group=None, target=None, name=None,
args=(), kwargs=None, *, daemon=None):
"""This constructor should always be called with keyword arguments. Arguments are:
*group* should be None; reserved for future extension when a ThreadGroup
class is implemented.
*target* is the callable object to be invoked by the run()
method. Defaults to None, meaning nothing is called.
*name* is the thread name. By default, a unique name is constructed of
the form "Thread-N" where N is a small decimal number.
*args* is the argument tuple for the target invocation. Defaults to ().
*kwargs* is a dictionary of keyword arguments for the target
invocation. Defaults to {}.
If a subclass overrides the constructor, it must make sure to invoke
the base class constructor (Thread.__init__()) before doing anything
else to the thread.创建两个线程
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time : 2018/5/23 21:49
# @Author : zhouyuyao
# @File : demon2.py
import threading
def worker(args):
print("开始子线程 {0}".format(args))
print("结束子线程 {0}".format(args))
if __name__ == '__main__':
print("start main")
t1 = threading.Thread(target=worker, args=(1,))
t2 = threading.Thread(target=worker, args=(2,))
t1.start()
t2.start()
print("end main")
''' 结果
start main
开始子线程 1
结束子线程 1
开始子线程 2
结束子线程 2
end main
'''2、lock
多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。
来看看多个线程同时操作一个变量怎么把内容给改乱了：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time : 2018/5/23 22:21
# @Author : zhouyuyao
# @File : demon3.py
import time, threading
# 假定这是你的银行存款:
balance = 0
def change_it(n):
# 先存后取，结果应该为0:
global balance
balance = balance + n
balance = balance - n
def run_thread(n):
for i in range(100000):
change_it(n)
def main():
t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)
if __name__ == '__main__':
main()我们定义了一个共享变量balance，初始值为0，并且启动两个线程，先存后取，理论上结果应该为0，但是，由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，balance的结果就不一定是0了。
原因是因为高级语言的一条语句在CPU执行时是若干条语句，即使一个简单的计算：
balance = balance + n也分两步：
'''
1、计算balance + n，存入临时变量中
2、将临时变量的值赋给balance
'''运行多次之后我们会发现，会出现不一样的结果。
究其原因，是因为修改balance需要多条语句，而执行这几条语句时，线程可能中断，从而导致多个线程把同一个对象的内容改乱了。
两个线程同时一存一取，就可能导致余额不对，你肯定不希望你的银行存款莫名其妙地变成了负数，所以，我们必须确保一个线程在修改 balance 的时候，别的线程一定不能改。
如果我们要确保 balance 计算正确，就要给 change_it() 上一把锁，当某个线程开始执行 change_it() 时，我们说，该线程因为获得了锁，因此其他线程不能同时执行 change_it() ，只能等待，直到锁被释放后，获得该锁以后才能改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。创建一个锁就是通过 threading.Lock() 来实现：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time : 2018/5/23 22:35
# @Author : zhouyuyao
# @File : demon4.py
import threading
balance = 0
lock = threading.Lock()
def change_it(n):
# 先存后取，结果应该为0:
global balance
balance = balance + n
balance = balance - n
def run_thread(n):
for i in range(100000):
# 先要获取锁:
lock.acquire()
try:
# 放心地改吧:
change_it(n)
finally:
# 改完了一定要释放锁:
lock.release()
def main():
t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)
if __name__ == '__main__':
main()
当多个线程同时执行 lock.acquire() 时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。
获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去，成为死线程。所以我们用try...finally 来确保锁一定会被释放。
锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。
多线程编程，模型复杂，容易发生冲突，必须用锁加以隔离，同时，又要小心死锁的发生。
Python 解释器由于设计时有 GIL 全局锁，导致了多线程无法利用多核。多线程的并发在 Python 中就是一个美丽的梦。
参考资料
1. https://blog.csdn.net/theonegis/article/details/69230167 Python多进程之进程池
2. http://www.runoob.com/python3/python3-multithreading.html