0. 什么是线程(thread)？

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。

另外，线程是进程中的一个实体，是被CPU独立调度和分派的基本单位，线程自己不独立拥有系统资源，但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。

一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。

每一个应用程序都至少有一个进程和一个线程。线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的被划分成一块一块的工作，称为多线程。

0. 进程和线程的区别

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

简而言之：

  1. 一个程序至少有一个进程,一个进程至少有一个线程。
  2. 线程的划分尺度小于进程，使得多线程程序的并发性高。
  3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
  4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
  5. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。

1. 线程

1.1 普通的多线程

在python中，threading模块提供线程的功能。通过它，我们可以轻易的在进程中创建多个线程。下面是个例子：

  1. import threading
  2. import time
  4. def show(arg):
  5.     time.sleep(1)
  6.     print('thread'+str(arg))
  8. for i in range(10):
  9.     t = threading.Thread(target=show, args=(i,))
  10.     t.start()
  12. print('main thread stop')

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。

下面是Thread类的主要方法：

  • start 线程准备就绪，等待CPU调度

  • setName 为线程设置名称

  • getName 获取线程名称

  • setDaemon 设置为后台线程或前台线程（默认是False，前台线程）

    如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止。如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止。

  • join 该方法非常重要。它的存在是告诉主线程，必须在这个位置等待子线程执行完毕后，才继续进行主线程的后面的代码。但是当setDaemon为True时，join方法是无效的。

  • run 线程被cpu调度后自动执行线程对象的run方法　　

1.2 自定义线程类

对于threading模块中的Thread类，本质上是执行了它的run方法。因此可以自定义线程类，让它继承Thread类，然后重写run方法。

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

1.3 线程锁(互斥锁Mutex)

CPU执行任务时，在线程之间是进行随机调度的，并且每个线程可能只执行n条代码后就转而执行另外一条线程。由于在一个进程中的多个线程之间是共享资源和数据的，这就容易造成资源抢夺或脏数据，于是就有了锁的概念，限制某一时刻只有一个线程能访问某个指定的数据。

1.3.1 未使用锁时：

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

上面未加锁的程序多运行几次你会发现，最后打印出来的num结果不总是0，为什么每次运行的结果不一样呢？是因为线程同时访问一个数据，产生了错误的结果。

为了解决这个问题，python在threading模块中定义了几种线程锁类，每个线程在要修改公共数据时，为了避免自己在还没改完的时候别人也来修改此数据，可以给这个数据加一把锁， 这样其它线程想修改此数据时就必须等待你修改完毕并把锁释放掉后才能再访问此数据。

1.3.2 普通锁（Lock）

  • 类名：Lock
  • 普通锁，也叫互斥锁，是独占的，同一时刻只有一个线程被放行。
  1. import time
  2. import threading
  4. def addNum():
  5.     global num #在每个线程中都获取这个全局变量
  6.     print('--get num:',num )
  7.     time.sleep(1)
  8.     lock.acquire() #修改数据前加锁
  9.     num  -=1 #对此公共变量进行-1操作
  10.     lock.release() #修改后释放
  12. num = 100  #设定一个共享变量
  13. thread_list = []
  14. lock = threading.Lock() #生成全局锁
  16. for i in range(100):
  17.     t = threading.Thread(target=addNum)
  18.     t.start()
  19.     thread_list.append(t)
  21. for t in thread_list: #等待所有线程执行完毕
  22.     t.join()
  24. print('final num:', num )

以上是threading模块的Lock类，它不支持嵌套锁。

1.3.3 递归锁（RLock）

RLcok类的用法和Lock一模一样，但它支持嵌套。

  1. import threading,time
  3. def run1():
  4.     print("grab the first part data")
  5.     lock.acquire()
  6.     global num
  7.     num +=1
  8.     lock.release()
  9.     return num
  11. def run2():
  12.     print("grab the second part data")
  13.     lock.acquire()
  14.     global  num2
  15.     num2+=1
  16.     lock.release()
  17.     return num2
  19. def run3():
  20.     lock.acquire()
  21.     res = run1()
  22.     print('--------between run1 and run2-----')
  23.     res2 = run2()
  24.     lock.release()
  25.     print(res,res2)
  27. if __name__ == '__main__':
  28.     num,num2 = 0,0
  29.     lock = threading.RLock()
  30.     for i in range(10):
  31.         t = threading.Thread(target=run3)
  32.         t.start()
  34. while threading.active_count() != 1:
  35.     print(threading.active_count())
  36. else:
  37.     print('----all threads done---')
  38.     print(num,num2)

1.4 信号量(Semaphore)

  • 类名：BoundedSemaphore
  • 这种锁允许一定数量的线程同时更改数据，它不是互斥锁。比如地铁安检，排队人很多，工作人员只允许一定数量的人进入安检区，其它的人继续排队。
  1. import threading,time
  3. def run(n):
  4.     semaphore.acquire()
  5.     time.sleep(1)
  6.     print("run the thread: %s\n" %n)
  7.     semaphore.release()
  9. if __name__ == '__main__':
  10.     num= 0
  11.     semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
  13.     for i in range(20):
  14.         t = threading.Thread(target=run,args=(i,))
  15.         t.start()
  17. while threading.active_count() != 1:
  18.     pass #print threading.active_count()
  19. else:
  20.     print('----all threads done---')
  21.     print(num)

1.5 事件(Event)

Python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

  • clear：将“Flag”设置为False
  • set：将“Flag”设置为True
  1. import threading
  3. def func(e,i):
  4.     print(i)
  5.     e.wait()  # 检测当前event是什么状态，如果是红灯，则阻塞，如果是绿灯则继续往下执行。默认是红灯。
  6.     print(i+100)
  8. event = threading.Event()
  9. for i in range(10):
  10.     t = threading.Thread(target=func, args=(event, i))
  11.     t.start()
  13. event.clear()  # 主动将状态设置为红灯
  14. inp = input(">>>")
  15. if inp == "1":
  16.     event.set() # 主动将状态设置为绿灯

1.6 条件（Condition）

使得线程等待，只有满足某条件时，才释放n个线程

  1. import threading
  3. def condition():
  4.     ret = False
  5.     r = input(">>>")
  6.     if r == "yes":
  7.         ret = True
  8.     return ret
  10. def func(conn, i):
  11.     print(i)
  12.     conn.acquire()
  13.     conn.wait_for(condition)  # 这个方法接受一个函数的返回值
  14.     print(i+100)
  15.     conn.release()
  17. c = threading.Condition()
  18. for i in range(10):
  19.     t = threading.Thread(target=func, args=(c, i,))
  20.     t.start()

上面的例子，每输入一次“yes”放行了一个线程。下面这个，可以选择一次放行几个线程。

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. import threading
  6. def run(n):
  7.     con.acquire()
  8.     con.wait()
  9.     print("run the thread: %s" %n)
  10.     con.release()
  12. if __name__ == '__main__':
  14.     con = threading.Condition()
  15.     for i in range(10):
  16.         t = threading.Thread(target=run, args=(i,))
  17.         t.start()
  19.     while True:
  20.         inp = input('>>>')
  21.         if inp == "q":
  22.             break
  23.         # 下面这三行是固定语法
  24.         con.acquire()
  25.         con.notify(int(inp))  # 这个方法接收一个整数，表示让多少个线程通过
  26.         con.release()

1.7 全局解释器锁（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占有着统治地位的使用量，所以，你懂的。

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

  • GIL对我们有什么影响？

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

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

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

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

1.8 定时器（Timer）

定时器，指定n秒后执行某操作。

  1. from threading import Timer
  3. def hello():
  4.     print("hello, world")
  6. t = Timer(1, hello)  # 表示1秒后执行hello函数
  7. t.start()

2. queue队列

通常而言，队列是一种先进先出的数据结构，与之对应的是堆栈这种后进先出的结构。但是在python中，它内置了一个queue模块，它不但提供普通的队列，还提供一些特殊的队列。具体如下：

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

2.1 queue.Queue 先进先出队列

这是最常用也是最普遍的队列，先看一个例子：

  1. import queue
  2. q = queue.Queue(5)
  3. q.put(1)
  4. q.put(2)
  5. q.put(3)
  7. print(q.get())    # output:1
  8. print(q.get())    # output:2
  9. print(q.get())    # output:3

Queue类的参数和方法:

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

  • 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。

  1. def join(self):
  2.     with self.all_tasks_done:
  3.         while self.unfinished_tasks:
  4.             self.all_tasks_done.wait()
  • task_done() 表示某个任务完成。每一条get语句后需要一条task_done。
  1. import queue
  2. q = queue.Queue(5)
  3. q.put(11)
  4. q.put(22)
  5. print(q.get())
  6. q.task_done()
  7. print(q.get())
  8. q.task_done()
  9. q.join()

2.2 LifoQueue：后进先出队列

类似于“堆栈”，后进先出。也较常用。

  1. import queue
  2. q = queue.LifoQueue()
  3. q.put(123)
  4. q.put(456)
  5. print(q.get())   # output: 456

2.3 PriorityQueue：优先级队列

带有权重的队列，每个元素都是一个元组，前面的数字表示它的优先级，数字越小优先级越高，同样的优先级先进先出

  1. q = queue.PriorityQueue()
  2. q.put((1,"one"))
  3. q.put((2,"two"))
  4. q.put((3,"three"))
  5. q.put((4,"four"))
  6. print(q.get())   # output: one

2.4 deque：双向队列

Queue和LifoQueue的“综合体”，双向进出。方法较多，使用复杂，慎用！

  1. q = queue.deque()
  2. q.append(123)
  3. q.append(333)
  4. q.appendleft(456)
  5. q.pop()
  6. q.popleft()

3. 生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式？

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式？

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

下面来学习一个最基本的生产者消费者模型的例子：

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. import time
  5. import queue
  6. import threading
  8. q = queue.Queue(10)
  9. def productor(i):
  10.     while True:
  11.         q.put("厨师 %s 做的包子！"%i)
  12.         time.sleep(2)
  14. def consumer(k):
  15.     while True:
  16.         print("顾客 %s 吃了一个 %s"%(k,q.get()))
  17.         time.sleep(1)
  19. for i in range(3):
  20.     t = threading.Thread(target=productor,args=(i,))
  21.     t.start()
  23. for k in range(10):
  24.     v = threading.Thread(target=consumer,args=(k,))
  25.     v.start()

4. 线程池

在使用多线程处理任务时也不是线程越多越好，由于在切换线程的时候，需要切换上下文环境，依然会造成cpu的大量开销。为解决这个问题，线程池的概念被提出来了。预先创建好一个较为优化的数量的线程，让过来的任务立刻能够使用，就形成了线程池。在python中，没有内置的较好的线程池模块，需要自己实现或使用第三方模块。下面是一个简单的线程池：

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. import queue
  5. import time
  6. import threading
  8. class MyThreadPool:
  9.     def __init__(self, maxsize=5):
  10.         self.maxsize = maxsize
  11.         self._q = queue.Queue(maxsize)
  12.         for i in range(maxsize):
  13.             self._q.put(threading.Thread)
  15.     def get_thread(self):
  16.         return self._q.get()
  18.     def add_thread(self):
  19.         self._q.put(threading.Thread)
  21. def task(i, pool):
  22.     print(i)
  23.     time.sleep(1)
  24.     pool.add_thread()
  26. pool = MyThreadPool(5)
  27. for i in range(100):
  28.     t = pool.get_thread()
  29.     obj = t(target=task, args=(i,pool))
  30.     obj.start()

上面的例子是把线程类当做元素添加到队列内。实现方法比较糙，每个线程使用后就被抛弃，一开始就将线程开到满，因此性能较差。下面是一个相对好一点的例子，在这个例子中，队列里存放的不再是线程对象，而是任务对象，线程池也不是一开始就直接开辟所有线程，而是根据需要，逐步建立，直至池满。通过详细的代码注释，应该会有个清晰的理解。

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. """
  5. 一个基于thread和queue的线程池，以任务为队列元素，动态创建线程，重复利用线程，
  6. 通过close和terminate方法关闭线程池。
  7. """
  8. import queue
  9. import threading
  10. import contextlib
  11. import time
  13. # 创建空对象,用于停止线程
  14. StopEvent = object()
  16. def callback(status, result):
  17.     """
  18.     根据需要进行的回调函数，默认不执行。
  19.     :param status: action函数的执行状态
  20.     :param result: action函数的返回值
  21.     :return:
  22.     """
  23.     pass
  25. def action(thread_name,arg):
  26.     """
  27.     真实的任务定义在这个函数里
  28.     :param thread_name: 执行该方法的线程名
  29.     :param arg: 该函数需要的参数
  30.     :return:
  31.     """
  32.     # 模拟该函数执行了0.1秒
  33.     time.sleep(0.1)
  34.     print("第%s个任务调用了线程 %s，并打印了这条信息！" % (arg+1, thread_name))
  36. class ThreadPool:
  38.     def __init__(self, max_num, max_task_num=None):
  39.         """
  40.         初始化线程池
  41.         :param max_num: 线程池最大线程数量
  42.         :param max_task_num: 任务队列长度
  43.         """
  44.         # 如果提供了最大任务数的参数，则将队列的最大元素个数设置为这个值。
  45.         if max_task_num:
  46.             self.q = queue.Queue(max_task_num)
  47.         # 默认队列可接受无限多个的任务
  48.         else:
  49.             self.q = queue.Queue()
  50.         # 设置线程池最多可实例化的线程数
  51.         self.max_num = max_num
  52.         # 任务取消标识
  53.         self.cancel = False
  54.         # 任务中断标识
  55.         self.terminal = False
  56.         # 已实例化的线程列表
  57.         self.generate_list = []
  58.         # 处于空闲状态的线程列表
  59.         self.free_list = []
  61.     def put(self, func, args, callback=None):
  62.         """
  63.         往任务队列里放入一个任务
  64.         :param func: 任务函数
  65.         :param args: 任务函数所需参数
  66.         :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数
  67.         1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
  68.         :return: 如果线程池已经终止，则返回True否则None
  69.         """
  70.         # 先判断标识，看看任务是否取消了
  71.         if self.cancel:
  72.             return
  73.         # 如果没有空闲的线程，并且已创建的线程的数量小于预定义的最大线程数，则创建新线程。
  74.         if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
  75.             self.generate_thread()
  76.         # 构造任务参数元组，分别是调用的函数，该函数的参数，回调函数。
  77.         w = (func, args, callback,)
  78.         # 将任务放入队列
  79.         self.q.put(w)
  81.     def generate_thread(self):
  82.         """
  83.         创建一个线程
  84.         """
  85.         # 每个线程都执行call方法
  86.         t = threading.Thread(target=self.call)
  87.         t.start()
  89.     def call(self):
  90.         """
  91.         循环去获取任务函数并执行任务函数。在正常情况下，每个线程都保存生存状态，
  92.         直到获取线程终止的flag。
  93.         """
  94.         # 获取当前线程的名字
  95.         current_thread = threading.currentThread().getName()
  96.         # 将当前线程的名字加入已实例化的线程列表中
  97.         self.generate_list.append(current_thread)
  98.         # 从任务队列中获取一个任务
  99.         event = self.q.get()
  100.         # 让获取的任务不是终止线程的标识对象时
  101.         while event != StopEvent:
  102.             # 解析任务中封装的三个参数
  103.             func, arguments, callback = event
  104.             # 抓取异常，防止线程因为异常退出
  105.             try:
  106.                 # 正常执行任务函数
  107.                 result = func(current_thread, *arguments)
  108.                 success = True
  109.             except Exception as e:
  110.                 # 当任务执行过程中弹出异常
  111.                 result = None
  112.                 success = False
  113.             # 如果有指定的回调函数
  114.             if callback is not None:
  115.                 # 执行回调函数，并抓取异常
  116.                 try:
  117.                     callback(success, result)
  118.                 except Exception as e:
  119.                     pass
  120.             # 当某个线程正常执行完一个任务时，先执行worker_state方法
  121.             with self.worker_state(self.free_list, current_thread):
  122.                 # 如果强制关闭线程的flag开启，则传入一个StopEvent元素
  123.                 if self.terminal:
  124.                     event = StopEvent
  125.                 # 否则获取一个正常的任务，并回调worker_state方法的yield语句
  126.                 else:
  127.                     # 从这里开始又是一个正常的任务循环
  128.                     event = self.q.get()
  129.         else:
  130.             # 一旦发现任务是个终止线程的标识元素，将线程从已创建线程列表中删除
  131.             self.generate_list.remove(current_thread)
  133.     def close(self):
  134.         """
  135.         执行完所有的任务后，让所有线程都停止的方法
  136.         """
  137.         # 设置flag
  138.         self.cancel = True
  139.         # 计算已创建线程列表中线程的个数，然后往任务队列里推送相同数量的终止线程的标识元素
  140.         full_size = len(self.generate_list)
  141.         while full_size:
  142.             self.q.put(StopEvent)
  143.             full_size -= 1
  145.     def terminate(self):
  146.         """
  147.         在任务执行过程中，终止线程，提前退出。
  148.         """
  149.         self.terminal = True
  150.         # 强制性的停止线程
  151.         while self.generate_list:
  152.             self.q.put(StopEvent)
  154.     # 该装饰器用于上下文管理
  155.     @contextlib.contextmanager
  156.     def worker_state(self, state_list, worker_thread):
  157.         """
  158.         用于记录空闲的线程，或从空闲列表中取出线程处理任务
  159.         """
  160.         # 将当前线程，添加到空闲线程列表中
  161.         state_list.append(worker_thread)
  162.         # 捕获异常
  163.         try:
  164.             # 在此等待
  165.             yield
  166.         finally:
  167.             # 将线程从空闲列表中移除
  168.             state_list.remove(worker_thread)
  170. # 调用方式
  171. if __name__ == '__main__':
  172.     # 创建一个最多包含5个线程的线程池
  173.     pool = ThreadPool(5)
  174.     # 创建100个任务，让线程池进行处理
  175.     for i in range(100):
  176.         pool.put(action, (i,), callback)
  177.     # 等待一定时间，让线程执行任务
  178.     time.sleep(3)
  179.     print("-" * 50)
  180.     print("\033[32;0m任务停止之前线程池中有%s个线程，空闲的线程有%s个！\033[0m"
  181.           % (len(pool.generate_list), len(pool.free_list)))
  182.     # 正常关闭线程池
  183.     pool.close()
  184.     print("任务执行完毕，正常退出！")
  185.     # 强制关闭线程池
  186.     # pool.terminate()
  187.     # print("强制停止任务！")

5. 进程

在python中multiprocess模块提供了Process类，实现进程相关的功能。但是，由于它是基于fork机制的，因此不被windows平台支持。想要在windows中运行，必须使用if __name__ == '__main__:的方式，显然这只能用于调试和学习，不能用于实际环境。

下面是一个简单的多进程例子，你会发现Process的用法和Thread的用法几乎一模一样。

  1. from multiprocessing import Process
  2. import time
  4. def f(name):
  5.     time.sleep(2)
  6.     print('hello', name)
  8. if __name__ == '__main__':
  9.     p = Process(target=f, args=('bob',))
  10.     p.start()
  11.     p.join()

5.1 进程的数据共享

每个进程都有自己独立的数据空间，不同进程之间通常是不能共享数据，创建一个进程需要非常大的开销。

  1. from multiprocessing import Process
  2. list_1 = []
  3. def foo(i):
  4.     list_1.append(i)
  5.     print("This is Process ", i," and list_1 is ", list_1)
  7. if __name__ == '__main__':
  8.     for i in range(5):
  9.         p = Process(target=foo, args=(i,))
  10.         p.start()
  12.     print("The end of list_1:", list_1)

运行上面的代码，你会发现列表list_1在各个进程中只有自己的数据，完全无法共享。想要进程之间进行资源共享可以使用queues/Array/Manager这三个multiprocess模块提供的类。

5.1.1 使用Array共享数据

  1. from multiprocessing import Process
  2. from multiprocessing import Array
  4. def Foo(i,temp):
  5.     temp[0] += 100
  6.     for item in temp:
  7.         print(i,'----->',item)
  9. if __name__ == '__main__':
  10.     temp = Array('i', [11, 22, 33, 44])
  11.     for i in range(2):
  12.         p = Process(target=Foo, args=(i,temp))
  13.         p.start()

对于Array数组类，括号内的“i”表示它内部的元素全部是int类型，而不是指字符i，列表内的元素可以预先指定，也可以指定列表长度。概括的来说就是Array类在实例化的时候就必须指定数组的数据类型和数组的大小，类似temp = Array('i', 5)。对于数据类型有下面的表格对应：

  1. 'c': ctypes.c_char, 'u': ctypes.c_wchar,
  2. 'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
  3. 'h': ctypes.c_short, 'H': ctypes.c_ushort,
  4. 'i': ctypes.c_int, 'I': ctypes.c_uint,
  5. 'l': ctypes.c_long, 'L': ctypes.c_ulong,
  6. 'f': ctypes.c_float, 'd': ctypes.c_double

5.1.2 使用Manager共享数据

  1. from multiprocessing import Process,Manager
  3. def Foo(i,dic):
  4.     dic[i] = 100+i
  5.     print(dic.values())
  7. if __name__ == '__main__':
  8.     manage = Manager()
  9.     dic = manage.dict()
  10.     for i in range(10):
  11.         p = Process(target=Foo, args=(i,dic))
  12.         p.start()
  13.         p.join()

Manager比Array要好用一点，因为它可以同时保存多种类型的数据格式。

5.1.3 使用queues的Queue类共享数据

  1. import multiprocessing
  2. from multiprocessing import Process
  3. from multiprocessing import queues
  5. def foo(i,arg):
  6.     arg.put(i)
  7.     print('The Process is ', i, "and the queue's size is ", arg.qsize())
  9. if __name__ == "__main__":
  10.     li = queues.Queue(20, ctx=multiprocessing)
  11.     for i in range(10):
  12.         p = Process(target=foo, args=(i,li,))
  13.         p.start()

这里就有点类似上面的队列了。从运行结果里，你还能发现数据共享中存在的脏数据问题。另外，比较悲催的是multiprocessing里还有一个Queue，一样能实现这个功能。

5.2 进程锁

为了防止和多线程一样的出现数据抢夺和脏数据的问题，同样需要设置进程锁。与threading类似，在multiprocessing里也有同名的锁类RLock, Lock, Event, Condition, Semaphore，连用法都是一样的！

  1. from multiprocessing import Process
  2. from multiprocessing import queues
  3. from multiprocessing import Array
  4. from multiprocessing import RLock, Lock, Event, Condition, Semaphore
  5. import multiprocessing
  6. import time
  8. def foo(i,lis,lc):
  9.     lc.acquire()
  10.     lis[0] = lis[0] - 1
  11.     time.sleep(1)
  12.     print('say hi',lis[0])
  13.     lc.release()
  15. if __name__ == "__main__":
  16.     # li = []
  17.     li = Array('i', 1)
  18.     li[0] = 10
  19.     lock = RLock()
  20.     for i in range(10):
  21.         p = Process(target=foo,args=(i,li,lock))
  22.         p.start()

5.3 进程池

既然有线程池，那必然也有进程池。但是，python给我们内置了一个进程池，不需要像线程池那样需要自定义，你只需要简单的from multiprocessing import Pool

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from multiprocessing import Pool
  4. import time
  6. def f1(args):
  7.     time.sleep(1)
  8.     print(args)
  10. if __name__ == '__main__':
  11.     p = Pool(5)
  12.     for i in range(30):
  13.         p.apply_async(func=f1, args= (i,))
  14.     p.close()           # 等子进程执行完毕后关闭进程池
  15.     # time.sleep(2)
  16.     # p.terminate()     # 立刻关闭进程池
  17.     p.join()

进程池内部维护一个进程序列，当使用时，去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有以下几个主要方法：

  • apply：从进程池里取一个进程并执行
  • apply_async：apply的异步版本
  • terminate:立刻关闭进程池
  • join：主进程等待所有子进程执行完毕。必须在close或terminate之后。
  • close：等待所有进程结束后，才关闭进程池。

6. 协程

线程和进程的操作是由程序触发系统接口，最后的执行者是系统，它本质上是操作系统提供的功能。而协程的操作则是程序员指定的，在python中通过yield，人为的实现并发处理。

协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时。协程，则只使用一个线程，分解一个线程成为多个“微线程”，在一个线程中规定某个代码块的执行顺序。

协程的适用场景：当程序中存在大量不需要CPU的操作时（IO）。

在不需要自己“造轮子”的年代，同样有第三方模块为我们提供了高效的协程，这里介绍一下greenlet和gevent。本质上，gevent是对greenlet的高级封装，因此一般用它就行，这是一个相当高效的模块。在使用它们之前，需要先安装，可以通过源码，也可以通过pip。

6.1 greenlet

  1. from greenlet import greenlet
  3. def test1():
  4.     print(12)
  5.     gr2.switch()
  6.     print(34)
  7.     gr2.switch()
  9. def test2():
  10.     print(56)
  11.     gr1.switch()
  12.     print(78)
  14. gr1 = greenlet(test1)
  15. gr2 = greenlet(test2)
  16. gr1.switch()

实际上，greenlet就是通过switch方法在不同的任务之间进行切换。

6.2 gevent

  1. from gevent import monkey; monkey.patch_all()
  2. import gevent
  3. import requests
  5. def f(url):
  6.     print('GET: %s' % url)
  7.     resp = requests.get(url)
  8.     data = resp.text
  9.     print('%d bytes received from %s.' % (len(data), url))
  11. gevent.joinall([
  12.         gevent.spawn(f, 'https://www.python.org/'),
  13.         gevent.spawn(f, 'https://www.yahoo.com/'),
  14.         gevent.spawn(f, 'https://github.com/'),
  15. ])

通过joinall将任务f 和它的参数进行统一调度，实现单线程中的协程。代码封装层次很高，实际使用只需要了解它的几个主要方法即可。

7. 论事件驱动与异步IO

通常，我们写服务器处理模型的程序时，有以下几种模型：

  1. 每收到一个请求，创建一个新的进程，来处理该请求；
  2. 每收到一个请求，创建一个新的线程，来处理该请求；
  3. 每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求

上面的几种方式，各有千秋，

  • 第1种方法，由于创建新的进程的开销比较大，所以，会导致服务器性能比较差,但实现比较简单。
  • 第2种方式，由于要涉及到线程的同步，有可能会面临死锁等问题。
  • 第3种方式，在写应用程序代码时，逻辑比前面两种都复杂。

综合考虑各方面因素，一般普遍认为第3种方式是大多数网络服务器采用的方式

7.1 Select\Poll\Epoll异步IO

7.1.1 Select

select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。

select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。

select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。

另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

7.1.2 Poll

poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。

poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。

7.1.3 epoll

直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。

epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。

epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。

另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

看到这里，貌似有了epoll，select之流可以退休了。但实际情况不是这样的。

  • windows暂时只支持seclet，它没有epoll....
  • select的各平台支持度比较好，API也比较通用，通俗点就是“皮实耐操通用性好舒适度差”；
  • epoll是linux内核原生支持的机制，虽然强大，但是各平台支持度不一样，API也差别较大，就是那种“高大上但局限性高”的东西。不过epoll显然是未来的大趋势。

参考博客：

银河系1234

Alex

Python-09-线程、进程、协程、异步IO的更多相关文章

  1. 12.python进程\协程\异步IO

    进程 创建进程 from multiprocessing import Process import time def func(name): time.sleep(2) print('hello', ...

  2. python中线程 进程 协程

    多线程:#线程的并发是利用cpu上下文的切换(是并发,不是并行)#多线程执行的顺序是无序的#多线程共享全局变量#线程是继承在进程里的,没有进程就没有线程#GIL全局解释器锁#只要在进行耗时的IO操作的 ...

  3. python 多协程异步IO爬取网页加速3倍。

    from urllib import request import gevent,time from gevent import monkey#该模块让当前程序所有io操作单独标记,进行异步操作. m ...

  4. 学到了林海峰,武沛齐讲的Day34 完 线程 进程 协程 很重要

    线程 进程 协程 很重要 ...儿子满月回家办酒,学的有点慢,坚持

  5. Python学习笔记整理总结【网络编程】【线程/进程/协程/IO多路模型/select/poll/epoll/selector】

    一.socket(单链接) 1.socket:应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口.在设计模式中,Socket其实就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socke ...

  6. Python进程、线程、协程及IO多路复用

    详情戳击下方链接 Python之进程.线程.协程 python之IO多路复用

  7. 11.python之线程，协程，进程，

    一,进程与线程 1.什么是线程 线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行 ...

  8. Python 协程/异步IO/Select\Poll\Epoll异步IO与事件驱动

    1 Gevent 协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到 ...

  9. Python全栈开发-Day10-进程/协程/异步IO/IO多路复用

    本节内容 多进程multiprocessing 进程间的通讯 协程 论事件驱动与异步IO Select\Poll\Epoll——IO多路复用   1.多进程multiprocessing Python ...

  10. Python 8 协程/异步IO

    协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来 ...

随机推荐

  1. Castle Windsor常用介绍以及其在ABP项目的应用介绍

    最近在研究ABP项目,有关ABP的介绍请看阳光铭睿 博客,ABP的DI和AOP框架用的是Castle Windsor下面就对Castle Windsor项目常用方法介绍和关于ABP的使用总结 1.下载 ...

  2. 【特别推荐】小伙伴们惊呆了！8个超炫的 Web 效果

    CodePen 是一个在线的 HTML.CSS 和 JavaScript 代码编辑器,能够编写代码并即时预览效果.你在上面可以在线展示自己的作品,也可以看到其他人在网页中实现的各种令人惊奇的效果. 今 ...

  3. jquery投色子动画

    可以点击这里体验效果:http://keleyi.com/keleyi/phtml/jqtexiao/26.htm 效果图: 代码如下: <!DOCTYPE HTML> <html& ...

  4. php 7.0 安装mcrypt

    1. 添加ppa源 sudo add-apt-repository ppa:ondrej/php 2. 升级源 sudo apt-get update && sudo apt-get ...

  5. Android UI:ListView -- SimpleAdapter

    SimpleAdapter是扩展性最好的适配器,可以定义各种你想要的布局,而且使用很方便. layout : <?xml version="1.0" encoding=&qu ...

  6. android 多线程

    本章讲述在android开发中,多线程的应用.多线程能够处理耗时的操作并优化程序的性能.本章主要介绍知识点,AsyncTask,Java线程池,ThreadPoolExecutor线程池类.本章案例只 ...

  7. UIweib的简单实用

  8. 极简MarkDown排版介绍（How to）

    如何切换编辑器 切换博客园编辑器为MarkDown:MarkDown Editor 选择一个在线编辑和预览站点:StackEdit 如何排版章节 MarkDown: 大标题 ========== 小标 ...

  9. Invoke--转载

    在多线程编程中,我们经常要在工作线程中去更新界面显示,而在多线程中直接调用界面控件的方法是错误的做法,Invoke 和 BeginInvoke 就是为了解决这个问题而出现的,使你在多线程中安全的更新界 ...

  10. Linux 硬盘分区生效命令partprobe

    在Linux中使用fdisk命令进行分区时,有时会遇到"WARNING: Re-reading the partition table failed with error 16: Devic ...