对于操作系统来说，一个任务就是一个进程(Process)，比如打开一个浏览器就是启动了一个浏览器进程，打开两个记事本就是启动了两个记事本进程。
有些进程不止同时干一件事，比如World，他可以同时打字，拼写检查，打印等。在一个进程内部，同时干多件事，就需要运行多个子任务，我们把进程内的这些子任务称为线程（Thread)
由于每个进程至少要干一件事，所以，一个进程至少有一个线程，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，方式和多进程一样。也是由操作系统在多个线程之间快速切换，让每个线程都短暂的交替执行，看起来就像同时执行一样。真正同时执行多线程需要多核CPU才能实现。
如何同时执行多个任务？
有两种解决方案：
- 一种是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。
- 启动一个进程，在一个进程内启动多个线程，多个线程一块执行多个任务
总结一下就是：多进程模式，多线程模式
同时执行多个任务，通常各个任务之间需要相互通信和协调，有时任务1必须暂停等任务2完成后才能继续执行，有时，任务3和4又不能同时执行，所以多线程和多进程程序福再度远高于单进程单线程程序。
因为复杂度高，调试困难，所以不到迫不得已，不需要写多任务。但是，很多时候，没有多任务不行，比如看电影，就必须有一个线程播放视频，一个线程播放音频，否则，单线程实现的话只能先把视频播放完在播放音频，或者先把音频播放完在播放视频，这显然是不行的
线程是最小执行单元，而进程由至少一个线程组成。
多进程
multiprocessing：模块是跨平台多进程模块，提供了一个Process类来代表一个进程对象，如下：
from multiprocessing import Process
import os
# 子进程要执行的代码
def run_proc(name):
print('Run child process %s (%s)...' % (name, os.getpid()))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test',))
print('Child process will start.')
p.start()
p.join()
print('Child process end.')
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动即可，join()方法可以等待子进程执行结束后再继续往下执行，通常用于进程间同步
Pool：如果要启动大量的子进程，可以用进程池的方式创建子进程：
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
执行结果如下：
Parent process 669.
Waiting for all subprocesses done...
Run task 0 (671)...
Run task 1 (672)...
Run task 2 (673)...
Run task 3 (674)...
Task 2 runs 0.14 seconds.
Run task 4 (673)...
Task 1 runs 0.27 seconds.
Task 3 runs 0.86 seconds.
Task 0 runs 1.41 seconds.
Task 4 runs 1.91 seconds.
All subprocesses done.
代码解读：对Pool对象调用join()方法会等待所有子进程执行完毕，调用jion()之前必须先调用close(),调用close()之后就不能添加新的Process了。
值得注意的是，task 0，1，2，3 是立刻执行，而 task 4 要等待某个task完成后才执行，这是因为设置Pool(4),最多同时执行4个进程，Pool的默认大小是CPU的核数
多线程
Python标准库提供了两个模块：_thread和threading,_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。
启动一个线程就是把一个函数传入，并创建Thread实例，然后调用start()开始执行
import time, threading
# 新线程执行的代码:
def loop():
print('thread %s is running...' % threading.current_thread().name)
n = 0
while n < 5:
n = n + 1
print('thread %s >>> %s' % (threading.current_thread().name, n))
time.sleep(1)
print('thread %s ended.' % threading.current_thread().name)
print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)
执行结果如下：
thread MainThread is running...
thread LoopThread is running...
thread LoopThread >>> 1
thread LoopThread >>> 2
thread LoopThread >>> 3
thread LoopThread >>> 4
thread LoopThread >>> 5
thread LoopThread ended.
thread MainThread ended.
任何进程默认会启动一个线程，我们称之为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，它永远返回当前线程实例，主线程实例的名字叫MainThread，子线程的名字在创建时指定，这里用LoopThread表示，名字仅仅打印时用来显示用，没有其他意义，不过不起名字，Python就自动给线程命名Thread-1,Thread-2...
Lock: 多线程和多进程最大的区别是，多进程中，同一个变量各自有一份拷贝在每个进程中，互不影响，而多线程中所有变量都有所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此线程之间共享数据的最大的危险在于多个线程同时改一个变量，把内容给改乱了。
为了保证计算正确，需要上一把锁，由于锁只有一个，无论多少线程，同一时刻只有一个线程持有该锁，不会造成修改冲突，创建一个锁是通过threading.Lock()来实现。
当多个线程同时执行lock.acquire()时，只有一个线程能成功获取锁，然后继续执行代码，其他线程就继续等待知道获得锁为止。
获得锁的线程用完后一定要释放锁，否则那些苦苦等待的线程将用于等待下去，称为死线程。所以我们用try...finally来确保锁一定被释放
锁的好处是确保了某段关键代码只能由一个线程从头到尾完整执行，也有很多坏处，包含锁的代码实际上只能以单线程运行，效率下降，其次，由于可以存在多个锁，不同线程持有不同的锁，并试图获取对方持有的锁时，可能造成死锁。导致线程全部挂起，既不能执行，也不能结束，只能靠操作系统强行终止
多线程编程，模型复杂，容易发生冲突，必须用锁加以隔离，同时，又小心死锁发生。
ThreadLocal：一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰，ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题
