操作系统学习实战篇——实现支持异步任务的线程池

Python同步原语

互斥锁

在每一次对临界资源进行读或写操作时，先加锁，操作完成之后再解锁。

Python互斥锁的使用：

lock = threading.Lock()  # 申请锁
lock.acquire()   # 加锁
lock.release()   # 解锁

条件变量

判断条件是否满足，一个线程在条件满足的时候执行；当条件不满足时睡眠，等待另一个线程满足条件将睡眠线程唤醒，使其继续执行下去。

Python条件变量的使用：

condition=threading.Condition()   # 申请条件变量
condition.acquire()               # 加锁
condition.release()               # 解锁
condition.wait()                  # 等待
condition.notify()                # 通知

实现线程安全的队列Queue

队列用于存放多个元素，是存放各种元素的“池”。

队列可能有多个线程同时操作，因此需要保证线程安全。两个线程安全的情况如下：

queue.py

# -*- encoding = utf-8 -*-
import threading
import time


class ThreadSafeQueueException(Exception):
    pass


class ThreadSafeQueue(object):

    def __init__(self,max_size=0):
        self.queue = []
        self.max_size = max_size
        self.lock = threading.Lock()
        self.condition = threading.Condition()

    # 获取当前队列中元素的数量
    def size(self):
        self.lock.acquire()
        size = len(self.queue)
        self.lock.release()
        return size

    # 往队列中放入元素
    def push(self,item):
        if self.size() != 0 and self.size() > self.max_size:
            return ThreadSafeQueueException
        self.lock.acquire()
        self.queue.append(item)
        self.lock.release()
        # 如果当前队列的size为0，一个线程去获取size时就会阻塞。
        # 当我们往队列中放入元素时，size不为0了，就可以通知阻塞线程继续执行。
        self.condition.acquire()
        self.condition.notify()
        self.condition.release()

    # 往队列中批量放入元素
    def batch_push(self,item_list):
        if not isinstance(item_list,list):
            item_list = list(item_list)
        for item in item_list:
            self.push(item)

    # 从队列中取出元素
    def pop(self, block=False, timeout=0):
        if self.size() == 0:
            # 需要阻塞等待
            if block:
                self.condition.acquire()
                self.condition.wait(timeout=timeout)
                self.condition