python 线程，进程与协程

import threading
import time
NUM = 0
def f1(i,lock):
global NUM
name = t.getName()#t是定义的线程，将这句代码放在线程锁之后会导致无法获取正确的线程名
lock.acquire() #定义锁作用空间的起始位置
NUM+=1
#name = threading.current_thread().name #等效于getName，不过输出的是每次执行的线程名
time.sleep(1)
print(name,i,'执行结果',NUM)
lock.release() #释放锁
lock = threading.RLock()
#lock = threading.Lock()
for i in range(30):
t = threading.Thread(target=f1,args=(i,lock,))
t.start()
#f1作为子线程执行，由于存在time.sleep(1)，当主进程执行完毕之后，子线程才开始执行。如果不使用线程锁的话结果出错。
print('执行结束')
线程锁

以上是threading模块的Lock类，它不支持嵌套锁。RLcok类的用法和Lock一模一样，但它支持嵌套，因此我们一般直接使用RLcok类。

信号量（Semaphore）

信号量根据设定的数值一次放行相应的数量的线程，它不是互斥锁。比如地铁安检，一次只能放行一定数量的人，剩下的继续排队等候。

import threading
import time
NUM = 0
def f1(i,lock):
global NUM
name = t.getName()
lock.acquire() #定义锁作用空间的起始位置
NUM+=1
name = t.getName()
time.sleep(1)
print(name,i,'执行结果',NUM)
lock.release() #释放锁
lock = threading.BoundedSemaphore(5)
for i in range(30):
t = threading.Thread(target=f1,args=(i,lock,))
t.start()
print('执行结束')
信号量

事件（Event）

类名：Event

事件主要提供了三个方法 set、wait、clear。

事件机制：全局定义了一个“Flag”，如果“Flag”的值为False，那么当程序执行wait方法时就会阻塞，如果“Flag”值为True，那么wait方法时便不再阻塞（wait默认为阻塞状态）。这种锁，类似交通红绿灯（默认是红灯），它属于在红灯的时候一次性阻挡所有线程，在绿灯的时候，一次性放行所有的排队中的线程。

clear：将“Flag”设置为False

set：将“Flag”设置为True

import threading
def func(e,i):
print(i)
e.wait() #检测当前event是什么状态，如果是红灯，则阻塞，绿灯则放行。默认为红灯。
print(i+100)
event = threading.Event()
for i in range(10):
t = threading.Thread(target=func,args=(event,i))
t.start()
event.clear() #将状态设置为红灯。
inp = input('>>> ')
if inp.strip() =='b':
event.set() #将状态设置为绿灯
事件

条件锁（condition）

条件锁会让线程等待直到满足条件是才释放进程

import threading
def condiction():
ret = False
inp = input('>>> ')
if inp == 'y':
ret = True
return ret
def func(cond,i):
print(i)
cond.acquire()
cond.wait_for(condiction)
#接受函数condition的返回值,Wait until a condition evaluates to True
print(i+100)
cond.release()
c=threading.Condition()
for i in range(10):
t = threading.Thread(target=func,args=(c,i))
t.start()
条件锁1

上面的例子每次只会释放一个线程。

import threading
def run(n):
con.acquire()
con.wait() #Wait until notified or until a timeout occurs
print('run this threading %s'%n)
con.release()
if __name__ == '__main__':
con= threading.Condition()
for i in range(10):
t = threading.Thread(target=run,args=(i,))
t.start()
while True:
inp = input('>>> ')
if inp =='q':
break
con.acquire()
con.notify(int(inp))
#根据条件唤醒一个到多个线程，如果线程之前没有处于acquire的Lock状态，则报错
#RuntimeError: cannot notify on un-acquired lock
con.release()
条件锁2

定时器（Timer）

指定程序在多长时间后执行某项操作

from threading import Timer
def hello():
print('hello')
t=Timer(1,hello) #延迟1s后执行
t.start()
定时器

全局解释器锁GIL（摘自刘江大哥博客）

既然介绍了多线程和线程锁，那就不得不提及python的GIL，也就是全局解释器锁。在编程语言的世界，python因为GIL的问题广受诟病，因为它在解释器的层面限制了程序在同一时间只有一个线程被CPU实际执行，而不管你的程序里实际开了多少条线程。所以我们经常能发现，python中的多线程编程有时候效率还不如单线程，就是因为这个原因。那么，对于这个GIL，一些普遍的问题如下：

每种编程语言都有GIL吗？

以python官方Cpython解释器为代表....其他语言好像未见。

为什么要有GIL？

作为解释型语言，Python的解释器必须做到既安全又高效。我们都知道多线程编程会遇到的问题。解释器要留意的是避免在不同的线程操作内部共享的数据。同时它还要保证在管理用户线程时总是有最大化的计算资源。那么，不同线程同时访问时，数据的保护机制是怎样的呢？答案是解释器全局锁GIL。GIL对诸如当前线程状态和为垃圾回收而用的堆分配对象这样的东西的访问提供着保护。

为什么不能去掉GIL？

首先，在早期的python解释器依赖较多的全局状态，传承下来，使得想要移除当今的GIL变得更加困难。其次，对于程序员而言，仅仅是想要理解它的实现就需要对操作系统设计、多线程编程、C语言、解释器设计和CPython解释器的实现有着非常彻底的理解。

在1999年，针对Python1.5，一个“freethreading”补丁已经尝试移除GIL，用细粒度的锁来代替。然而，GIL的移除给单线程程序的执行速度带来了一定的负面影响。当用单线程执行时，速度大约降低了40%。虽然使用两个线程时在速度上得到了提高，但这个提高并没有随着核数的增加而线性增长。因此这个补丁没有被采纳。

另外，在python的不同解释器实现中，如PyPy就移除了GIL，其执行速度更快（不单单是去除GIL的原因）。然而，我们通常使用的CPython占有着统治地位的使用量，所以，你懂的。

在Python 3.2中实现了一个新的GIL，并且带着一些积极的结果。这是自1992年以来，GIL的一次最主要改变。旧的GIL通过对Python指令进行计数来确定何时放弃GIL。在新的GIL实现中，用一个固定的超时时间来指示当前的线程以放弃这个锁。在当前线程保持这个锁，且当第二个线程请求这个锁的时候，当前线程就会在5ms后被强制释放掉这个锁（这就是说，当前线程每5ms就要检查其是否需要释放这个锁）。当任务是可行的时候，这会使得线程间的切换更加可预测。

GIL对我们有什么影响？

最大的影响是我们不能随意使用多线程。要区分任务场景。

在单核cpu情况下对性能的影响可以忽略不计，多线程多进程都差不多。在多核CPU时，多线程效率较低。GIL对单进程和多进程没有影响。

在实际使用中有什么好的建议？

建议在IO密集型任务中使用多线程，在计算密集型任务中使用多进程。深入研究python的协程机制，你会有惊喜的。

来源： http://www.cnblogs.com/feixuelove1009/p/5683159.html

关于GIL，发现一个比较有意思的文章

http://www.cnblogs.com/mindsbook/archive/2009/10/15/thread-safety-and-GIL.html#id3

二、队列

队列是一种规整的数据结构，和后进先出的堆栈不同，队列是一种先进先出的结构，就像一根管子，最先进去的数据也最先被得到。但是在Python中，提供一个queue模块，不仅可以实现普通队列，还提供几种特殊的队列。

queue.Queue ：先进先出队列 queue.LifoQueue ：后进先出队列 queue.PriorityQueue ：优先级队列 queue.deque ：双向队列

Queue：先进先出队列

import queue
q = queue.Queue(5)#定义最大元素个数
q.put(11)
q.put(22)
q.put(33)
print(q.get())
print(q.get())
print(q.get())
Queue

Queue类的方法：

maxsize 队列的最大元素个数，也就是 queue.Queue(5) 中的5。当队列内的元素达到这个值时，后来的元素默认会阻塞，等待队列腾出位置。

def __init__(self, maxsize=0):self.maxsize = maxsize
self._init(maxsize) qsize() 获取当前队列中元素的个数，也就是队列的大小 empty() 判断当前队列是否为空，返回True或者False full() 判断当前队列是否已满，返回True或者False

put(self, block=True, timeout=None)

往队列里放一个元素，默认是阻塞和无时间限制的。如果，block设置为False，则不阻塞，这时，如果队列是满的，放不进去，就会弹出异常。如果timeout设置为n秒，则会等待这个秒数后才put，如果put不进去则弹出异常。

get(self, block=True, timeout=None)
从队列里获取一个元素。参数和put是一样的意思。

join() 阻塞进程，直到所有任务完成，需要配合另一个方法task_done。

def join(self):with self.all_tasks_done:
while self.unfinished_tasks:
self.all_tasks_done.wait()

task_done() 表示某个任务完成。每一条get语句后需要一条task_done。

import queue
q = queue.Queue(5)
q.put(11)
q.put(22)
print(q.get())
q.task_done()
print(q.get())
q.task_done()
q.join()　　

LifoQueue：后进先出队列

import queue
q = queue.LifoQueue()
q.put(123)
q.put(456)
print(q.get())
LifoQueue

PriorityQueue：优先级队列

每个元素都是一个元组，第一位表