Python 3（15）多线程

Python3 入门专栏

http://blog.youkuaiyun.com/column/details/19679.html

Python 3 多线程

python 3 提供了 threading 模块用于支持多线程，用于代替 python 2 中的 thread 模块（该模块在 python 3中已经废弃），常用的模块如下：

• _thread：用于向下兼容 python 2 中的 thread 模块；
  
• threading：多线程模块；

该模块下的的多线程机制类似于 Java，即：由执行程序所表示的单一进程中创建任务，竞争 cpu 时间同样也是抢占式的；

---

_thread 模块

python 的 _thread 模块用于创建简单线程；

可以使用  _thread.start_new_thread (function, args）函数创建新线程：

• function：线程 run 方法函数；
  
• args：向线程 run 方法传递的参数，为一个元组对象
  

 

import time

import _thread

​

# 线程 run 方法

def delay_print(thread_name, delay, print_content):

    count = delay

    while count >= 0:

        print("[%s] %d sec" % (thread_name, count))

        count -= 1

        time.sleep(1)

    print("[%s] %s" % (thread_name, print_content))

​

# 创建线程

_thread.start_new_thread(delay_print, ("Thread-1", 3, "Are you OK? Mi fans!"))

_thread.start_new_thread(delay_print, ("Thread-2", 5, "Derk dark ♂ fantastic"))

​

# 当前线程待命

while True:

    pass

输出以下：

[Thread-1] 3 sec

[Thread-2] 5 sec

[Thread-2] 4 sec

[Thread-1] 2 sec

[Thread-2] 3 sec

[Thread-1] 1 sec

[Thread-2] 2 sec

[Thread-1] 0 sec

[Thread-2] 1 sec

[Thread-1] Are you OK? Mi fans!

[Thread-2] 0 sec

[Thread-2] Derk dark ♂ fantastic

---

threading 模块

以上 _thread 模块只提供了低级别原始的线程，和一个简单的线程锁，而 threading 模块提供了更多的功能；

threading 除了包含 _thread 模块已有的所有方法外，还含有以下方法：

threading.currentThread()	返回当前线程变量
threading.enumerate()	返回一个包含正在运行线程的 list（即启动后、结束前的线程）
threading.activeCount()	返回正在运行的线程数量，同len(threading.enumerate())

由 threading 创建的Thread 类提供了以下线程方法：

Thread.isAive()	检查线程是否活动
Thread.getName()	获取线程名
Thread.setName()	设置线程名
Thread.isDaemon()	检查线程是否为后台线程
Thread.setDaemon()	设置线程为后台线程
Thread.run()	运行线程
Thread.start()	启动线程
Thread.join([time])	当前线程等待至调用线程 Thread 结束或终止，这个阻塞直到 Thread.join() 方法调用终止（正常退出，或抛出未处理的异常，或可选参数中的超时发生）

python threading 模块并没有提供线程暂停、线程中止的方法，实际上当 Thread 启动（调用 start() ）后，线程处于失控状态，在 threading 模块提供的功能中无法控制线程的状态；

线程中断，可以通过手动发送一个 OS 中断信号来实现，详见下方；

线程暂停，可以通过实现线程锁来实现，详见下方：

创建线程

以下使用 threading 创建和以上 _thread 示例中一样功能的线程：

 

import time

import threading

​

# 线程实现类

class MyThread(threading.Thread):

​

    def __init__(self, thread_name, delay, print_content):

        threading.Thread.__init__(self)

        self.thread_name = thread_name

        self.delay = delay

        self.print_content = print_content

​

    def run(self):

        count = self.delay

        while count >= 0:

            print("[%s] %d sec" % (self.thread_name, count))

            count -= 1

            time.sleep(1)

        print("[%s] %s" % (self.thread_name, self.print_content))

​

# 创建线程

thread1 = MyThread("Thread-1", 3, "Are you OK? Mi fans!")

thread2 = MyThread("Thread-2", 3, "Derk dark ♂ fantastic")

​

# 运行线程

thread1.start()

thread2.start()

# 主线程阻塞直到2个线程执行结束

thread1.join()  

thread2.join()

print("[Thead-main] all thread completed")

输出：

[Thread-1] 3 sec

[Thread-2] 3 sec

[Thread-2] 2 sec

[Thread-1] 2 sec

[Thread-1] 1 sec

[Thread-2] 1 sec

[Thread-2] 0 sec

[Thread-1] 0 sec

[Thread-1] Are you OK? Mi fans!

[Thread-2] Derk dark ♂ fantastic

[Thead-main] all thread completed

线程中断的实现

theading.Thread 的线程中断，需要自己手动实现，可以类似如下：

 

import time

import threading

​

# 线程实现类，通过一个私有变量 running 来标志运行状态

class MyThread(threading.Thread):

​

    def __init__(self, delay):

        threading.Thread.__init__(self)

        self.delay = delay

        self.__running = True

​

    def interupt(self):

        self.__running = False

        print("thread is interrupt")

​

    def run(self):

        count = self.delay

        while count >= 0 and self.__running:

            print("%d sec" % count)

            count -= 1

            time.sleep(1)

        print("thread running completed")

​

​

# 创建线程

thread1 = MyThread(10)

​

# 运行线程

thread1.start()

# 3s 后中断线程 thread1

time.sleep(3)

thread1.interupt()

输出：

10 sec

9 sec

8 sec

thread is interrupt

thread running completed

线程同步

1）threading.Lock 和 threading.RLock 对象

• threading 的 Lock 和 Rlock 对象用于对线程同步提供简单的支持，类似于 Java 的 Lock 对象，该对象有acquire() 、release() 方法分别用于加线程锁、释放线程锁；
  
• Lock 和 RLock 的区别：RLock 允许在同一线程被多次 acquire，而 Lock 不允许这种情况，使用 RLock 的时候，acquire 和 release 必须成对出现，才能真正释放被占用的锁；
  

以下示例：

 

# 示例多个线程获取一个共享资源，每次获取 Resource 并减少 Resource.__count 值

import random

import time

import threading

​

# 线程实现类

class MyThread(threading.Thread):

​

    def __init__(self, thread_name, resource):

        threading.Thread.__init__(self)

        self.thread_name = thread_name

        self.__resource = resource

​

    def run(self):

        # 获取资源起始数量

        lock.acquire()

        count = self.__resource.get_count()

        lock.release()

        while count >= 0:

            # 获取资源，并修改 resource._count 值

            lock.acquire()

            count = self.__resource.get_count()

            count -= 1

            print("[%s] resource-count: %d" % (self.thread_name, count))

            self.__resource.set_count(count)

            lock.release()

            # 模拟处理资源时间

            time.sleep(random.random() * 3)

​

# 资源对象，储存线程共享资源

class Resource:

​

    def __init__(self, count):

        self.__count = count

​

    def get_count(self):

        return self.__count

​

    def set_count(self, count):

        self.__count = count

​

if __name__ == "__main__":

    resource = Resource(100)   # 创建资源（包含100个资源值）

    lock = threading.Lock()    # 创建线程锁对象

    threadpool = list()        # 使用一个list作为线程池

​

    # 向线程池中添加 5 个线程

    for i in range(1, 6):

        threadpool.append(MyThread("Thread-"+str(i), resource))

​

    # 运行线程池中的所有线程

    for thread in threadpool:

        thread.start()

    for thread in threadpool:

        thread.join()

输出：

[Thread-1] resource-count: 99

[Thread-2] resource-count: 98

[Thread-3] resource-count: 97

[Thread-4] resource-count: 96

[Thread-5] resource-count: 95

[Thread-1] resource-count: 94

[Thread-5] resource-count: 93

[Thread-4] resource-count: 92

[Thread-1] resource-count: 91

[Thread-5] resource-count: 90

......

2）threading.Condition 对象

threading.Condition 提供了比 Lock，RLock 更加高级的功能，允许控制更加复杂的线程同步问题，内部维护一个锁对象（默认为 RLock），可以在创建 Condition 对象时将锁对象作为参数传入；

同样的 Condition 提供了 acquire() 、release() 方法，常用方法如下：

Condition.acquire()	调用线程获取锁
Condition.release()	调用线程释放锁
Condition.wait([timeout])	调用线程释放锁，同时调用线程被挂起，直到被唤醒（或超时）时才重新获取锁，并继续执行下去；
Condition.notify()	唤醒任意一个挂起线程（如果存在挂起的线程），但是不会释放锁占用的锁
Confition.notifyAll()	同上，不过唤醒所有挂起线程，所有线程重新开始竞争CPU时间

以下使用 Codition 来实现一个经典的 生产者/消费者（producer / consumer） 模型：

 

import random

import time

import threading

​

# 生产者线程

class Producer(threading.Thread):

​

    def __init__(self, thread_name):

        threading.Thread.__init__(self)

        self.__thread_name = thread_name

​

    def run(self):

        while True:

            product = random.randrange(0, 100, 10)  # 模拟生产产品

            time.sleep(random.random() * 2)       # 模拟处理时间

            condition.acquire()

            resources.append(product)      # 向资源列表添加产品

            print("[%s] create product: %d , resource size: %d" % (self.__thread_name, product, len(resources)))

            condition.notify()             #唤醒一个挂起线程

            condition.release()

​

​

# 消费者线程

class Consumer(threading.Thread):

​

    def __init__(self, thread_name):

        threading.Thread.__init__(self)

        self.__thread_name = thread_name

​

    def run(self):

        while True:

            condition.acquire()

            if len(resources) <= 0:   # 当资源列表为空时，线程挂起

                condition.wait()

            product = resources.pop()    # 获取资源

            print("[%s] get product: %d , resource size: %d" % (self.__thread_name, product, len(resources)))

            condition.release()

            # 模拟处理资源时间

            time.sleep(random.random() * 8)

​

if __name__ == "__main__":

    resources = list()           # 资源列表对象

    condition = threading.Condition()

    threadpool = list()         # 线程池对象

​

    # 向线程池中添加 1 个生产者线程、3个消费者线程

    threadpool.append(Producer("Productor-1"))

    threadpool.append(Consumer("Consumer-1"))

    threadpool.append(Consumer("Consumer-2"))

    threadpool.append(Consumer("Consumer-3"))

​

    # 运行线程池中的所有线程

    for thread in threadpool:

        thread.start()

    for thread in threadpool:

        thread.join()

​

输出：

[Productor-1] create product: 50 , resource size: 1

[Consumer-1] get product: 50 , resource size: 0

[Productor-1] create product: 30 , resource size: 1

[Consumer-3] get product: 30 , resource size: 0

[Productor-1] create product: 50 , resource size: 1

[Productor-1] create product: 50 , resource size: 2

[Productor-1] create product: 80 , resource size: 3

[Consumer-1] get product: 80 , resource size: 2

[Productor-1] create product: 10 , resource size: 3

[Consumer-3] get product: 10 , resource size: 2

[Productor-1] create product: 40 , resource size: 3

.......

---

线程优先队列

python 内置的 queue 模块中提供了同步、线程安全的队列类，包括 FIFO 队列 Queue，LIFO 队列 LifoQueue，优先队列 PriorityQueue；

这些队列都是实现了锁原语，可以直接在多线程中使用，可以在队列中实现线程将的同步；

这些队列类的常用方法如下：

Queue.qsize()	返回队列的大小
Queue.empty()	如果队列为空，返回True
Queue.full()	如果队列满了，返回True，与 maxsize 大小对应
Queue.get([block[, timeout]])	获取队列，timeout等待时间，block 为是否阻塞，默认为 True
Queue.put(item [，block[, timeout]])	写入队列，timeout等待时间，block 为是否阻塞，默认为 True
Queue.task_done()	在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join()	意味着等到队列为空，再执行别的操作

实际上 Queue 这种特性，很适合用来编写 生产者/消费者 模型；

以下用 Queue 改写以上的 生产者/消费者 示例：

 

# 示例多个线程获取一个共享资源，每次获取 Resource 并减少 Resource.__count 值

import queue

import random

import time

import threading

​

​

# 生产者线程

class Producer(threading.Thread):

​

    def __init__(self, thread_name):

        threading.Thread.__init__(self)

        self.__thread_name = thread_name

​

    def run(self):

        while True:

            product = random.randrange(0, 100, 10)  # 模拟生产产品

            time.sleep(random.random() * 2)       # 模拟处理时间

            resources.put(product)      # 向资源列表添加产品

            print("[%s] create product: %d , resource size: %d" % (self.__thread_name, product, resources.qsize()))

​

​

# 消费者线程

class Consumer(threading.Thread):

​

    def __init__(self, thread_name):

        threading.Thread.__init__(self)

        self.__thread_name = thread_name

​

    def run(self):

        while True:

            product = resources.get()    # 获取资源

            print("[%s] get product: %d , resource size: %d" % (self.__thread_name, product, resources.qsize()))

            # 模拟处理资源时间

            time.sleep(random.random() * 8)

​

if __name__ == "__main__":

    resources = queue.Queue(maxsize=15)    # 使用同步队列作为资源储存

    threadpool = list()

​

    # 向线程池中添加 1 个生产者线程、3个消费者线程

    threadpool.append(Producer("Productor-1"))

    threadpool.append(Consumer("Consumer-1"))

    threadpool.append(Consumer("Consumer-2"))

    threadpool.append(Consumer("Consumer-3"))

​

    # 运行线程池中的所有线程

    for thread in threadpool:

        thread.start()

    for thread in threadpool:

        thread.join()