python学习笔记-（十三）线程、进程、多线程&多进程

为了方便大家理解下面的知识，可以先看一篇文章：http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

线程

1.什么是线程？

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

2.python GIL全局解释器锁（仅需了解）

无论你启多少个线程，你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行

首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

这篇文章透彻的剖析了GIL对python多线程的影响，强烈推荐看一下：http://www.dabeaz.com/python/UnderstandingGIL.pdf

3.python threading模块

threading模块建立在_thread 模块之上。thread模块以低级、原始的方式来处理和控制线程，而threading 模块通过对thread 进行二次封装，提供了更方便的 api来处理线程。

线程有两种调用方式，如下：

1）直接调用

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

import threading import time    def sayhi(num): #定义每个线程要运行的函数        print("running on number:%s" %num)        time.sleep(3)    if __name__ == '__main__':        t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例     t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例        t1.start() #启动线程     t2.start() #启动另一个线程        print(t1.getName()) #获取线程名     print(t2.getName())

2）继承调用

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import threading import time       class MyThread(threading.Thread):     def __init__(self,num):         threading.Thread.__init__(self)         self.num = num        def run(self):#定义每个线程要运行的函数            print("running on number:%s" %self.num)            time.sleep(3)    if __name__ == '__main__':        t1 = MyThread(1)     t2 = MyThread(2)     t1.start()     t2.start()

Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。

thread 模块提供的其他方法：

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

4.Join & Daemon

join 等待线程执行完后，其他线程再继续执行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

import  threading,time    def run(n,sleep_time):     print("test...",n)     time.sleep(sleep_time)     print("test...done", n) if __name__ == '__main__':        t1 = threading.Thread(target=run,args=("t1",2))     t2 = threading.Thread(target=run,args=("t2",3))        # 两个同时执行，然后等待t1执行完成后，主线程和子线程再开始执行     t1.start()     t2.start()     t1.join()   # 等待t1        print("main thread")    # 程序输出 # test... t1 # test... t2 # test...done t1 # main thread # test...done t2

Daemon 守护进程

t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

import threading,time    def run(n):     print('[%s]------running----\n' % n)     time.sleep(2)     print('--done--')       def main():     for i in range(5):         t = threading.Thread(target=run, args=[i, ])         t.start()         t.join(1)         print('starting thread', t.getName())       m = threading.Thread(target=main, args=[]) m.setDaemon(True)  # 将main线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,                     # m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务 m.start() m.join(timeout=2) print("---main thread done----")    # 程序输出 # [0]------running---- # starting thread Thread-2 # [1]------running---- # --done-- # ---main thread done----

5.线程锁（互斥锁Mutex）

我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。

例：假设列表A的所有元素就为0，当一个线程从前向后打印列表的所有元素，另外一个线程则从后向前修改列表的元素为1,那么输出的时候，列表的元素就会一部分为0，一部分为1,这就导致了数据的不一致。锁的出现解决了这个问题。

不加锁：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import time import threading       def addNum():     global num  # 在每个线程中都获取这个全局变量     print('--get num:', num)     time.sleep(1)     num -= 1  # 对此公共变量进行-1操作       num = 100  # 设定一个共享变量 thread_list = [] for i in range(100):     t = threading.Thread(target=addNum)     t.start()     thread_list.append(t)    for t in thread_list:  # 等待所有线程执行完毕     t.join()    print('final num:', num)

加锁：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

import time import threading       def addNum():     global num  # 在每个线程中都获取这个全局变量     print('--get num:', num)     time.sleep(1)     lock.acquire()  # 修改数据前加锁     num -= 1  # 对此公共变量进行-1操作     lock.release()  # 修改后释放       num = 100  # 设定一个共享变量 thread_list = [] lock = threading.Lock()  # 生成全局锁 for i in range(100):     t = threading.Thread(target=addNum)     t.start()     thread_list.append(t)    for t in thread_list:  # 等待所有线程执行完毕     t.join()    print('final num:', num)

GIL VS LOCK

机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock? 注意啦，这里的lock是用户级的lock,跟那个GIL没关系 ，具体我们通过下图来看一下+配合我现场讲给大家，就明白了。

6.递归锁

说白了就是在一个大锁中还要再包含子锁

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

import threading, time       def run1():     print("grab the first part data")     lock.acquire()     global num     num += 1     lock.release()     return num       def run2():     print("grab the second part data")     lock.acquire()     global num2     num2 += 1     lock.release()     return num2       def run3():     lock.acquire()     res = run1()     print('--------between run1 and run2-----')     res2 = run2()     lock.release()     print(res, res2)       if __name__ == '__main__':        num, num2 = 0, 0     lock = threading.RLock()     for i in range(10):         t = threading.Thread(target=run3)         t.start()    while threading.active_count() != 1:     print(threading.active_count()) else:     print('----all threads done---')     print(num, num2)

threading.RLock和threading.Lock 的区别：

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

1 2 3 4 5 6

import threading lock = threading.Lock()    #Lock对象 lock.acquire() lock.acquire()  #产生了死琐。 lock.release() lock.release()

1 2 3 4 5 6

import threading rLock = threading.RLock()  #RLock对象 rLock.acquire() rLock.acquire()    #在同一线程内，程序不会堵塞。 rLock.release() rLock.release()

7.信号量

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import threading,time    def run(n):     semaphore.acquire()     time.sleep(1)     print("run the thread: %s\n" %n)     semaphore.release()    if __name__ == '__main__':        num= 0     semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行     for i in range(20):         t = threading.Thread(target=run,args=(i,))         t.start()    while threading.active_count() != 1:     pass #print threading.active_count() else:     print('----all threads done---')     print(num)

8.event

Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

• Event.wait([timeout]) ：堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
• Event.set() ：将标识位设为Ture
• Event.clear() ：将标识伴设为False。
• Event.isSet() ：判断标识位是否为Ture。

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

import threading,time import random def light():     if not event.isSet():         event.set() #wait就不阻塞 #绿灯状态     count = 0     while True:         if count < 10:             print('\033[42;1m--green light on---\033[0m')         elif count <13:             print('\033[43;1m--yellow light on---\033[0m')         elif count <20:             if event.isSet():                 event.clear()             print('\033[41;1m--red light on---\033[0m')         else:             count = 0             event.set() #打开绿灯         time.sleep(1)         count +=1 def car(n):     while 1:         time.sleep(random.randrange(10))         if  event.isSet(): #绿灯             print("car [%s] is running.." % n)         else:             print("car [%s] is waiting for the red light.." %n) if __name__ == '__main__':     event = threading.Event()     Light = threading.Thread(target=light)     Light.start()     for i in range(3):         t = threading.Thread(target=car,args=(i,))         t.start()

9.队列

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

先入先出：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#先入先出 import queue q = queue.Queue() for i in range(5):     q.put(i) while not q.empty():     print(q.get())   #输出结果 #0 #1 #2 #3 #4

后入先出：

1 2 3 4 5 6 7 8 9 10 11 12 13

#后入先出 import queue q = queue.LifoQueue() for i in range(5):     q.put(i) while not q.empty():     print(q.get()) #输出结果 #4 #3 #2 #1 #0

优先级队列：

10.生产者消费者模型

进程

线程和进程的区别