标签：
引言
线程
创建普通多线程
线程锁
互斥锁
信号量
事件
条件锁
定时器
全局解释器锁
队列
Queue：先进先出队列
LifoQueue：后进先出队列
PriorityQueue：优先级队列
deque：双向队列
在学习过socket和socketserver后，我们了解到socketserver可以支持IO多路复用。在定义socketserver服务端的时候一般会使用：
server = socketserver.ThreadingTCPServer(settings.IP_PORT, MyServer)
ThreadingTCPServer这个类便是可以支持多线程和TCP协议的socketserver模块。读源码的时候可以发现其继承关系：
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
右边的TCPServer实际上是它主要的功能父类，而左边的ThreadingMixIn则是实现了多线程的类，它自己本身则没有任何代码。MixIn在python的类命名中，很常见，一般被称为“混入”，戏称“乱入”，通常为了某种重要功能被子类继承。
class ThreadingMixIn:
daemon_threads = False
def process_request_thread(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
t = threading.Thread(target = self.process_request_thread,
args = (request, client_address))
t.daemon = self.daemon_threads
t.start()
import threading
import time
def show(arg):
time.sleep(1)
print(‘thread‘+str(arg))
for i in range(10):
t = threading.Thread(target=show, args=(i,))
t.start()
print(‘main thread stop‘)
import threading class MyThread(threading.Thread): def __init__(self,func,args): self.func = func self.args = args super(MyThread,self).__init__() #继承父类构造方法 def run(self): self.func(self.args) def f2(arg): print(arg) obj = MyThread(f2,123) obj.start()
#!/usr/bin/env python
# _*_ coding:utf_8 _*_
import threading
import time
NUM = 0
def f1():
global NUM
NUM+=1
name = t.getName()
time.sleep(1)
print(name,‘执行结果‘,NUM)
for i in range(10):
t = threading.Thread(target=f1)
t.start()
#f1作为子线程执行，由于存在time.sleep(1)，当主进程执行完毕之后，子线程才开始执行。导致结果出错。
print(‘执行结束‘)
执行结果：
执行结束 Thread-1 执行结果 10 Thread-4 执行结果 10 Thread-3 执行结果 10 Thread-5 执行结果 10 Thread-2 执行结果 10 Thread-6 执行结果 10 Thread-8 执行结果 10 Thread-7 执行结果 10 Thread-10 执行结果 10 Thread-9 执行结果 10
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(‘执行结束‘)
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(‘执行结束‘)
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() #将状态设置为绿灯
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()
上面的例子每次只会释放一个线程。
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()
from threading import Timer def hello(): print(‘hello‘) t=Timer(1,hello) #延迟1s后执行 t.start()
既然介绍了多线程和线程锁，那就不得不提及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的协程机制，你会有惊喜的。
import queue q = queue.Queue(5)#定义最大元素个数 q.put(11) q.put(22) q.put(33) print(q.get()) print(q.get()) print(q.get())
maxsize 队列的最大元素个数，也就是queue.Queue(5)中的5。当队列内的元素达到这个值时，后来的元素默认会阻塞，等待队列腾出位置。
def __init__(self, maxsize=0):self.maxsize = maxsize
self._init(maxsize)put(self, block=True, timeout=None)
往队列里放一个元素，默认是阻塞和无时间限制的。如果，block设置为False，则不阻塞，这时，如果队列是满的，放不进去，就会弹出异常。如果timeout设置为n秒，则会等待这个秒数后才put，如果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()
import queue q = queue.LifoQueue() q.put(123) q.put(456) print(q.get())
q = queue.PriorityQueue() q.put((1,"zhang1")) q.put((1,"zhang2")) q.put((1,"zhang3")) q.put((3,"zhang3")) print(q.get())
q = queue.deque() q.append(11) q.append(22) q.appendleft(33) q.appendleft(44) print(q.popleft()) print(q.popleft()) print(q.pop()) print(q.pop()) q.append(55)
标签：
原文地址：http://www.cnblogs.com/ernest-zhang/p/5693661.html
