多线程编程

其实创建线程之后，线程并不是始终保持一个状态的，其状态大概如下：

  • New 创建
  • Runnable 就绪。等待调度
  • Running 运行
  • Blocked 阻塞。阻塞可能在 Wait Locked Sleeping
  • Dead 消亡

线程有着不同的状态，也有不同的类型。大致可分为：

  • 主线程
  • 子线程
  • 守护线程（后台线程）
  • 前台线程

简单了解完这些之后，我们开始看看具体的代码使用了。

1、线程的创建

Python 提供两个模块进行多线程的操作，分别是 thread 和 threading

前者是比较低级的模块，用于更底层的操作，一般应用级别的开发不常用。

  1. #!/usr/bin/env python3
  2. # -*- coding: UTF-8 -*-
  4. import time
  5. import threading
  8. class MyThread(threading.Thread):
  9.     def run(self):
  10.         for i in range(5):
  11.             print('thread {}, @number: {}'.format(self.name, i))
  12.             time.sleep(1)
  15. def main():
  16.     print("Start main threading")
  18.     # 创建三个线程
  19.     threads = [MyThread() for i in range(3)]
  20.     # 启动三个线程
  21.     for t in threads:
  22.         t.start()
  24.     print("End Main threading")
  27. if __name__ == '__main__':
  28.     main()

运行结果：

  1. Start main threading
  2. thread Thread-1, @number: 0
  3. thread Thread-2, @number: 0
  4. thread Thread-3, @number: 0
  5. End Main threading
  6. thread Thread-2, @number: 1
  7. thread Thread-1, @number: 1
  8. thread Thread-3, @number: 1
  9. thread Thread-1, @number: 2
  10. thread Thread-3, @number: 2
  11. thread Thread-2, @number: 2
  12. thread Thread-2, @number: 3
  13. thread Thread-3, @number: 3
  14. thread Thread-1, @number: 3
  15. thread Thread-3, @number: 4
  16. thread Thread-2, @number: 4
  17. thread Thread-1, @number: 4

注意喔，这里不同的环境输出的结果肯定是不一样的。

2、线程合并（join方法）

上面的示例打印出来的结果来看，主线程结束后，子线程还在运行。那么我们需要主线程要等待子线程运行完后，再退出，要怎么办呢？

这时候，就需要用到 join 方法了。

在上面的例子，新增一段代码，具体如下：

  1. #!/usr/bin/env python3
  2. # -*- coding: UTF-8 -*-
  4. import time
  5. import threading
  8. class MyThread(threading.Thread):
  9.     def run(self):
  10.         for i in range(5):
  11.             print('thread {}, @number: {}'.format(self.name, i))
  12.             time.sleep(1)
  15. def main():
  16.     print("Start main threading")
  18.     # 创建三个线程
  19.     threads = [MyThread() for i in range(3)]
  20.     # 启动三个线程
  21.     for t in threads:
  22.         t.start()
  24.     # 一次让新创建的线程执行 join
  25.     for t in threads:
  26.         t.join()
  28.     print("End Main threading")
  31. if __name__ == '__main__':
  32.     main()

从打印的结果，可以清楚看到，相比上面示例打印出来的结果，主线程是在等待子线程运行结束后才结束的。

  1. Start main threading
  2. thread Thread-1, @number: 0
  3. thread Thread-2, @number: 0
  4. thread Thread-3, @number: 0
  5. thread Thread-1, @number: 1
  6. thread Thread-3, @number: 1
  7. thread Thread-2, @number: 1
  8. thread Thread-2, @number: 2
  9. thread Thread-1, @number: 2
  10. thread Thread-3, @number: 2
  11. thread Thread-2, @number: 3
  12. thread Thread-1, @number: 3
  13. thread Thread-3, @number: 3
  14. thread Thread-3, @number: 4
  15. thread Thread-2, @number: 4
  16. thread Thread-1, @number: 4
  17. End Main threading

3、线程同步与互斥锁

使用线程加载获取数据，通常都会造成数据不同步的情况。当然，这时候我们可以给资源进行加锁，也就是访问资源的线程需要获得锁才能访问。

其中 threading 模块给我们提供了一个 Lock 功能。

  1. lock = threading.Lock()

在线程中获取锁

  1. lock.acquire()

使用完成后，我们肯定需要释放锁

  1. lock.release()

当然为了支持在同一线程中多次请求同一资源，Python 提供了可重入锁（RLock）。RLock 内部维护着一个 Lock 和一个 counter 变量，counter 记录了 acquire 的次数，从而使得资源可以被多次 require。直到一个线程所有的 acquire 都被 release，其他的线程才能获得资源。

那么怎么创建重入锁呢？也是一句代码的事情：

  1. r_lock = threading.RLock()

4、Condition 条件变量

实用锁可以达到线程同步，但是在更复杂的环境，需要针对锁进行一些条件判断。Python 提供了 Condition 对象。使用 Condition 对象可以在某些事件触发或者达到特定的条件后才处理数据，Condition 除了具有 Lock 对象的 acquire 方法和 release 方法外，还提供了 wait 和 notify 方法。线程首先 acquire 一个条件变量锁。如果条件不足，则该线程 wait，如果满足就执行线程，甚至可以 notify 其他线程。其他处于 wait 状态的线程接到通知后会重新判断条件。

其中条件变量可以看成不同的线程先后 acquire 获得锁，如果不满足条件，可以理解为被扔到一个（ Lock 或 RLock ）的 waiting 池。直达其他线程 notify 之后再重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

Condition

该模式常用于生产者消费者模式，具体看看下面在线购物买家和卖家的示例：

  1. #!/usr/bin/env python3
  2. # -*- coding: UTF-8 -*-
  4. import threading, time
  7. class Consumer(threading.Thread):
  8.     def __init__(self, cond, name):
  9.         # 初始化
  10.         super(Consumer, self).__init__()
  11.         self.cond = cond
  12.         self.name = name
  14.     def run(self):
  15.         # 确保先运行Seeker中的方法
  16.         time.sleep(1)
  17.         self.cond.acquire()
  18.         print(self.name + ': 我这两件商品一起买，可以便宜点吗')
  19.         self.cond.notify()
  20.         self.cond.wait()
  21.         print(self.name + ': 我已经提交订单了，你修改下价格')
  22.         self.cond.notify()
  23.         self.cond.wait()
  24.         print(self.name + ': 收到，我支付成功了')
  25.         self.cond.notify()
  26.         self.cond.release()
  27.         print(self.name + ': 等待收货')
  30. class Producer(threading.Thread):
  31.     def __init__(self, cond, name):
  32.         super(Producer, self).__init__()
  33.         self.cond = cond
  34.         self.name = name
  36.     def run(self):
  37.         self.cond.acquire()
  38.         # 释放对琐的占用，同时线程挂起在这里，直到被 notify 并重新占有琐。
  39.         self.cond.wait()
  40.         print(self.name + ': 可以的，你提交订单吧')
  41.         self.cond.notify()
  42.         self.cond.wait()
  43.         print(self.name + ': 好了，已经修改了')
  44.         self.cond.notify()
  45.         self.cond.wait()
  46.         print(self.name + ': 嗯，收款成功，马上给你发货')
  47.         self.cond.release()
  48.         print(self.name + ': 发货商品')
  51. cond = threading.Condition()
  52. consumer = Consumer(cond, '买家（两点水）')
  53. producer = Producer(cond, '卖家（三点水）')
  54. consumer.start()
  55. producer.start()

输出的结果如下：

  1. 买家（两点水）: 我这两件商品一起买，可以便宜点吗
  2. 卖家（三点水）: 可以的，你提交订单吧
  3. 买家（两点水）: 我已经提交订单了，你修改下价格
  4. 卖家（三点水）: 好了，已经修改了
  5. 买家（两点水）: 收到，我支付成功了
  6. 买家（两点水）: 等待收货
  7. 卖家（三点水）: 嗯，收款成功，马上给你发货
  8. 卖家（三点水）: 发货商品

5、线程间通信

如果程序中有多个线程，这些线程避免不了需要相互通信的。那么我们怎样在这些线程之间安全地交换信息或数据呢？

从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程通过使用 put() 和 get() 操作来向队列中添加或者删除元素。

  1. # -*- coding: UTF-8 -*-
  2. from queue import Queue
  3. from threading import Thread
  5. isRead = True
  8. def write(q):
  9.     # 写数据进程
  10.     for value in ['两点水', '三点水', '四点水']:
  11.         print('写进 Queue 的值为：{0}'.format(value))
  12.         q.put(value)
  15. def read(q):
  16.     # 读取数据进程
  17.     while isRead:
  18.         value = q.get(True)
  19.         print('从 Queue 读取的值为：{0}'.format(value))
  22. if __name__ == '__main__':
  23.     q = Queue()
  24.     t1 = Thread(target=write, args=(q,))
  25.     t2 = Thread(target=read, args=(q,))
  26.     t1.start()
  27.     t2.start()

输出的结果如下：

  1. 写进 Queue 的值为：两点水
  2. 写进 Queue 的值为：三点水
  3. 从 Queue 读取的值为：两点水
  4. 写进 Queue 的值为：四点水
  5. 从 Queue 读取的值为：三点水
  6. 从 Queue 读取的值为：四点水

Python 还提供了 Event 对象用于线程间通信，它是由线程设置的信号标志，如果信号标志位真，则其他线程等待直到信号接触。

Event 对象实现了简单的线程通信机制，它提供了设置信号，清楚信号，等待等用于实现线程间的通信。

  • 设置信号

使用 Event 的 set() 方法可以设置 Event 对象内部的信号标志为真。Event 对象提供了 isSe() 方法来判断其内部信号标志的状态。当使用 event 对象的 set() 方法后，isSet() 方法返回真

  • 清除信号

使用 Event 对象的 clear() 方法可以清除 Event 对象内部的信号标志，即将其设为假，当使用 Event 的 clear 方法后，isSet() 方法返回假

  • 等待

Event 对象 wait 的方法只有在内部信号为真的时候才会很快的执行并完成返回。当 Event 对象的内部信号标志位假时，则 wait 方法一直等待到其为真时才返回。

示例：

  1. # -*- coding: UTF-8 -*-
  3. import threading
  6. class mThread(threading.Thread):
  7.     def __init__(self, threadname):
  8.         threading.Thread.__init__(self, name=threadname)
  10.     def run(self):
  11.         # 使用全局Event对象
  12.         global event
  13.         # 判断Event对象内部信号标志
  14.         if event.isSet():
  15.             event.clear()
  16.             event.wait()
  17.             print(self.getName())
  18.         else:
  19.             print(self.getName())
  20.             # 设置Event对象内部信号标志
  21.             event.set()
  23. # 生成Event对象
  24. event = threading.Event()
  25. # 设置Event对象内部信号标志
  26. event.set()
  27. t1 = []
  28. for i in range(10):
  29.     t = mThread(str(i))
  30.     # 生成线程列表
  31.     t1.append(t)
  33. for i in t1:
  34.     # 运行线程
  35.     i.start()

输出的结果如下：

  1. 1
  2. 0
  3. 3
  4. 2
  5. 5
  6. 4
  7. 7
  8. 6
  9. 9
  10. 8

6、后台线程

默认情况下，主线程退出之后，即使子线程没有 join。那么主线程结束后，子线程也依然会继续执行。如果希望主线程退出后，其子线程也退出而不再执行，则需要设置子线程为后台线程。Python 提供了 setDeamon 方法。