标签：
详细链接http://www.cnblogs.com/alex3714/articles/5230609.html
1.线程：包含在进程中，是操作系统运算调度的最小单位，是一串指令的集合，直接与cpu交互
2进程：进程是一个程序各种资源的集合。操作系统通过管理这个集合进而运行程序，进程本身并不执行，进程通过调用线程来调度cpu。
3.不同点：
一个线程可以控制和操作同一进程里的其他线程，但是进程只能操作子进程
创建新线程很简单，但是创建一个子进程需要对父进程进行拷贝
线程共享内存，进程的内存是独立的
线程间可以直接交流数据，进程之间不能直接交流数据
4.多线程示例：
1 import threading 2 import time 3 def run(n,m): 4 print("task",n,m) 5 t1 = threading.Thread(target=run,args=(‘t1‘,‘f‘,)) #args是函数参数的集合，注意逗号 7 t2 = threading.Thread(target=run,args=(‘t2‘,‘g‘,)) 8 t1.start() 9 t2.start() 10 11 输出： 12 task t1 f 13 task t2 g
5.计算线程总共花费的时间：
threading.Thread.join() 等待start的线程运行结束
1 import threading 2 import time 3 t_list = [] 4 start_time = time.time() 5 def run(): 6 print("task") 7 time.sleep(3) 8 print("ok") 9 for i in range(50): 10 t = threading.Thread(target=run) 11 t.start() 12 t_list.append(t) 13 cc = [] 14 print(t_list) 15 for t in t_list: 16 t.join() 17 c = time.time()-start_time 18 cc.append(c) 19 print(cc) 20 cost = time.time()-start_time 21 print("cost",cost) 22 23 24 输出：cost 3.009999990463257
6.将线程设置为守护线程，主进程执行完后程序就结束退出了，不会等守护线程执行结束
一、设置守护进程
import threading import time t_list = [] start_time = time.time() def run(): print("task") time.sleep(3) print("ok") for i in range(50): t = threading.Thread(target=run) t.setDaemon(True) #将线程设置为守护线程 t.start() t_list.append(t) cost = time.time()-start_time print("cost",cost) 输出：cost 0.0070040225982666016
二、不设置守护线程
import threading import time t_list = [] start_time = time.time() def run(): print("task") time.sleep(3) print("ok") for i in range(50): t = threading.Thread(target=run) ##t.setDaemon(True) #未将线程设置为守护线程 t.start() t_list.append(t) for t in t_list: 去 ‘’ t.join() cost = time.time()-start_time print("cost",cost) 输出：cost 3.0090019702911377
7.在python2中，有时候线程会重复执行相同的操作，比如：从1加，一直,加到结果等于1000，可能会出现结果等于987或其他结果， 这时要使多线程变成串行。
线程锁(互斥锁Mutex)
例子：
1 import threading 2 import time 3 t_list = [] 4 start_time = time.time() 5 lock = threading.Lock() #先实例化一个锁 6 num = 0 7 def run(): #只需在这个函数内加锁即可 8 lock.acquire() #获取一把锁 9 print("task") 10 global num 11 num = num +1 12 time.sleep(1) 13 print("ok") 14 print(num) 15 lock.release() #将锁释放 16 for i in range(50): 17 t = threading.Thread(target=run) 18 t.setDaemon(True) 19 t.start() 20 t_list.append(t) 21 22 cc = [] 23 for t in t_list: 24 t.join() 25 c = time.time()-start_time 26 cc.append(c) 27 print(cc) 28 cost = time.time()-start_time 29 print("cost",cost) 30 31 32 33 输出：结果符合预期
8.threading.active_count() #获取当前活动线程的数量，返回一个数值
9.信号量：
sem = threading.BoundedSemaphore(5)#实例化信号量，指定同一时间只运行5个线程，当有一个线程运行完后，增加一个新的线程运行。
1 import threading 2 import time 3 sem = threading.BoundedSemaphore(5) 4 t_list = [] 5 start_time = time.time() 6 def run(): 7 # lock.acquire() 8 sem.acquire() 9 print("task") 10 time.sleep(1) 11 print(""" 12 ****************** 13 """) 14 print("ok") 15 sem.release() 16 for i in range(20): 17 t = threading.Thread(target=run) 18 t.start() 19 t_list.append(t) 20 cost = time.time()-start_time 21 print("cost",cost) 22 23 输出：task 24 task 25 task 26 task 27 task 28 cost 0.0040018558502197266 29 30 ****************** 31 32 ****************** 33 34 ****************** 35 36 ok 37 38 39 ok 40 ok 41 task 42 task 43 task
10.线程标记位 event.set() event.clear() event.is_set()
import threading import time event = threading.Event() def lighter(): count = 0 event.set()#设置标记位 while True: if count > 5 and count < 10: event.clear()#清除标记位 print("\033[41;1m红灯\033[0m") elif count > 10: event.set()#设置标记位 count = 0#count清0，重新累加 else: print("\033[42;1m绿灯\033[0m") time.sleep(1) count += 1 def car(name): while True: if event.is_set():#判断是否是标记位，代表绿灯 print("%s开车"%name) time.sleep(1) else: print("%s停车"%name) event.wait()#等待设置新的标记位，当新的标记位产生后，跳出else light = threading.Thread(target=lighter,) light.start() car1 = threading.Thread(target=car,args=(‘Tesla‘,)) car1.start() 输出：绿灯 Tesla开车 Tesla开车 绿灯 绿灯 Tesla开车 绿灯 Tesla开车 绿灯 Tesla开车 Tesla开车 绿灯 红灯 Tesla停车 红灯 红灯 红灯 绿灯 Tesla开车
11.队列
queue.Queue(maxsize=0) #先入先出
queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
queue.LifoQueue(maxsize=0) #后入先出
创建一个“队列”对象
import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。
将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。
将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。
Python Queue模块有三种队列及构造函数:
1、Python Queue模块的FIFO队列先进先出。 class Queue.Queue(maxsize)
2、LIFO类似于堆，即先进后出。 class Queue.LifoQueue(maxsize)
3、还有一种是优先级队列级别越低越先出来。 class Queue.PriorityQueue(maxsize)
此包中的常用方法(q = Queue.Queue()):
q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)
非阻塞 q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作
一些需要注意的地方：
1. 阻塞模式
import Queue
q = Queue.Queue(10)
......
for i in range(10):
q.put(‘A‘)
time.sleep(0.5)
这是一段极其简单的代码（另有两个线程也在操作队列q），我期望每隔0.5秒写一个‘A‘到队列中，但总是不能如愿：间隔时间有时会远远超过0.5秒。原来，Queue.put（）默认有 block = True 和 timeou 两个参数。当 block = True 时，写入是阻塞式的，阻塞时间由 timeou 确定。当队列q被（其他线程）写满后，这段代码就会阻塞，直至其他线程取走数据。Queue.put（）方法加上 block=False 的参数，即可解决这个隐蔽的问题。但要注意，非阻塞方式写队列，当队列满时会抛出 exception Queue.Full 的异常。
2. 无法捕获 exception Queue.Empty 的异常
while True:
......
try:
data = q.get()
except Queue.Empty:
break
我的本意是用队列为空时，退出循环，但实际运行起来，却陷入了死循环。这个问题和上面有点类似：Queue.get（）默认的也是阻塞方式读取数据，队列为空时，不会抛出 except Queue.Empty ，而是进入阻塞直至超时。 加上block=False 的参数，问题迎刃而解。
标签：
原文地址：http://www.cnblogs.com/wt11/p/5879720.html
