标签：
一. 进程：
基本使用
进程锁
进程池
进程数据共享
二. 线程：
基本使用
线程锁
线程池
队列（生产者消费者模型）
三. 协程：
gevent
greenlet
四. 缓存：
memcache
redis
（一）线程：
所有的线程都运行于一个进程中，一个进程中可以执行多个线程。多个线程共享进程内的资源。所以可以将线程可以看成是共享同一虚拟内存以及其他属性的进程。
（二）进程：
进程是程序的一次执行，每个进程都有自己的地址空间，内存，数据栈。创建进程的时候，内核会为进程分配一定的资源，并在进程存活的时候不断进行调整，比如内存，进程创建的时候会占有一部分内存。进程结束的时候资源会释放出来，来让其他资源使用。我们可以把进程理解为一种容器，容器内的资源可多可少，但是只能进程间通信，不能共享信息。
谈到进程则要用到的就是multiprocessing模块，这个模块的所有功能基本都是在进程上的。
定义一个类运行一个进程：
process([group[,target [,name [,args [,kwargs]]]]])
group：一般不使用，默认为None
target: 当进程启动时执行的可调用对象
name: 为进程执行描述性名称的字符串
args: 位置参数，元组
kwargs: 位置参数，字典
通过这个构造函数简单构造了一个process进程。
进程（process）实例：
p.is_alive() #如果p仍然运行，返回True p.join([timeout]) #等待进程p终止，timeout是可选的超时期限。进程可被连接无数次，但连接自身时则会报错 p.run()# 启动进程时运行的方法，可调用target。 p.start() #启动进程，代表进程的子进程，并调用p.run()函数 p.terminate()#强制终止进程。进程p被立即终止，而不会进行清理，慎用。
单进程实例：
import multiprocessing import time def clock(interval): while True: print("The time is %s" % time.ctime()) time.sleep(interval) if __name__ == ‘__main__‘: p = multiprocessing.Process(target=clock, args=(5,)) p.start() The time is Fri Jul 22 17:15:45 2016 The time is Fri Jul 22 17:15:50 2016 The time is Fri Jul 22 17:15:55 2016
将上面的进程定义为继承自Process的类，目的为为了实现跨平台的可移植性，必须有主程序创建进程。
1 import multiprocessing 2 import time 3 4 class ClockProcess(multiprocessing.Process): 5 def __init__(self, interval): 6 multiprocessing.Process.__init__(self) 7 self.interval = interval 8 9 def run(self): 10 while True: 11 print("The time is %s" % time.ctime()) 12 time.sleep(self.interval) 13 if __name__ == ‘__main__‘: 14 p = ClockProcess(5) 15 p.start() 16 17 The time is Fri Jul 22 17:25:08 2016 18 The time is Fri Jul 22 17:25:13 2016 19 The time is Fri Jul 22 17:25:18 2016
进程锁：
当多个进程需要访问共享资源的时候，Lock可以用来避免访问的冲突。
1 import multiprocessing 2 import sys 3 4 def worker_with(lock, f): 5 with lock: 6 fs = open(f,"a+") 7 fs.write(‘Lock acquired via \n‘) 8 fs.close() 9 10 def worker_no_with(lock, f): 11 lock.acquire() 12 try: 13 fs = open(f,"a+") 14 fs.write(‘Lock acquired directly\n‘) 15 fs.close() 16 finally: 17 lock.release() 18 19 if __name__ == "__main__": 20 21 f = "file.txt" 22 23 lock = multiprocessing.Lock() 24 w = multiprocessing.Process(target=worker_with, args=(lock, f)) 25 nw = multiprocessing.Process(target=worker_no_with, args=(lock, f)) 26 27 w.start() 28 nw.start() 29 30 w.join() 31 nw.join() 32 33 34 #cat file.txt 35 36 Lock acquired directly 37 Lock acquired via
注：如果两个进程没有使用lock来同步,则他们对同一个文件的写操作可能会出现混乱。
进程池：
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。
创建一个进程池：
Pool([numprocess [,initializer [, initargs]]])
numprocess: 要创建的进程数
initlalizer: 每个工作进程启动时要执行的可调用对象，默认为None
initargs： 传递给initlalizer的元组
Pool的实例：
p.apply(func, [, args [, kwargs]])#在一个池工作进程中执行函数(**args, **kwargs),然后返回结果，不能再池中并行执行，可使用apply_async p.apply_async(func, [, args [, kwargs [,callback]]])#在一个池工作进程中异步执行函数(**args, **kwargs),然后返回结果，传递给callback。 p.terminate()#立即终止 p.close()# 关闭进程池 p.join()# 等待所有工作进程退出
案例：
1 from multiprocessing import Pool 2 import time 3 4 def f1(arg): 5 time.sleep(3) 6 print(arg) 7 8 if __name__ == ‘__main__‘: 9 pool = Pool(5) #并发执行5个函数 10 11 for i in range(15): 12 #pool.apply(func=f1,args=(i,))#不能并发的执行函数 13 pool.apply_async(func=f1,args=(i,))#可并发执行函数 14 15 pool.close() #所有的任务执行完毕 16 time.sleep(3) 17 #pool.terminate()#立即终止 18 pool.join()
进程数据共享：
（三）协程：
协程我们可以看成是一种用户空间的线程，利用一个线程，分解一个线程成为多个“微线程”
标签：
原文地址：http://www.cnblogs.com/python-nameless/p/5696278.html
