• 多线程编程
    • 1、线程的创建
    • 2、线程合并（join方法）
    • 3、线程同步与互斥锁
    • 4、Condition 条件变量
    • 5、线程间通信
    • 6、后台线程

    多线程编程

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

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