操作系统--实例5(实现支持异步任务的线程池)

最新推荐文章于 2022-08-13 21:07:49 发布
最新推荐文章于 2022-08-13 21:07:49 发布
阅读量345 收藏 1
点赞数 1
分类专栏： 计算机基础 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ANingL/article/details/108286954
版权

文章目录

一、背景介绍

实现支持异步任务的线程池
使用python3

  • 很多语言都提供了线程池
    • Java:ThreadPoolExecutor
    • Python3:ThreadPoolExecutor

本篇的主要内容：在这里插入图片描述

二、python的同步原语

1、互斥量

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

2、条件变量

  • 申请条件变量：condition=threading.Condition()
  • 加锁：condition.acquire()
  • 解锁：condition.release()
  • 等待：condition.wait()
  • 唤醒：condition.notify()
  • python中不需要将条件变量和互斥量自己结合，threading库直接将互斥量放入条件变量中

三、实现线程安全的队列Queue

1、队列

  • 队列用于存放多个元素，是存放各种元素的池
    • 存放的元素可以是线程，可以是任务，也可以是别的

2、实现线程安全的队列的功能

  • 获取当前队元素数量
  • 往队列放入元素
  • 从队列取出元素

3、什么会影响线程安全

队列可能有多个线程同时操作，因此需要保证线程安全

比如：

  • 场景： 多个线程同时访问队列元素
    • 目的： 为了保证多个线程获取的串行
    • 方法： 使用“锁”保护队列
  • 场景： 队列元素为空时获取队列元素，
    • 目的： 此时阻塞线程，等待队列到队列不为空，
    • 方法： 使用条件变量等待队列元素不为空

4、编程实现

queue.py

import threading
# 线程安全的队列
import time


class ThreadSafeQueueException(Exception):
    pass
class ThreadSafeQueue(object):
    # 构造函数
    def __init__(self,max_size=0):
        # max_size表示队列长度，0表示无限大
        self.queue=[]
        self.max_size=max_size
        self.lock=threading.Lock()   # 互斥量
        self.condition=threading.Condition()  # 条件变量
    # 获取当前元素的数量，通过获取queue的长度
    # 为了防止在获取过程中队列被调用，在获取之前之后对队列加锁解锁
    def size(self):
        self.lock.acquire()
        size=len(self.queue)
        self.lock.release()
        return size

    # 给队列中放入元素
    def put(self,item):
        if self.max_size!=0 and self.size()>self.max_size:
            return ThreadSafeQueueException()
        else:
            self.lock.acquire()
            self.queue.append(item)
            self.lock.release()
            self.condition.acquire()
            self.condition.notify()
            self.condition.release()
            pass
    def batcjh_put(self,item_list):
        if not isinstance(item_list,list):
            item_list=list(item_list)
            for item in item_list:
                self.put(item)
        pass
    # 从队列中取出元素,block参数用来在队列中无元素时阻塞进程，timeout用来在阻塞时设置阻塞时间
    def pop(self,block=False,timeout=0):
        # 从队列头部取出
        if self.size==0:
            if block:
                self.condition.acquire()
                self.condition.wait(timeout=timeout)
                self.condition.release()
            else:
                return None
        self.lock.acquire()
	item=None
	if len(self.queue)>0:
	    item=self.queue.pop()
	self.lock.release()
	return item
		
    def get(self,index):
        self.lock.acquire()
        item=self.queue[index]
        self.lock.release()
        return item
if __name__ == '__main__':
    queue=ThreadSafeQueue(max_size=100)
    def producer():
        while True:
            queue.put(1)
            time.sleep(1)
    def consumer():
        while True:
            item=queue.pop(1)
            print('get item from queue:',item)
            time.sleep(1)
    thread1=threading.Thread(target=producer)
    thread2=threading.Thread(target=consumer)
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()

四、实现基本任务对象Task

1、概念

指放入队列中的任务对象

  • 实现基本任务对象需要
    • 任务参数
    • 任务唯一标记(uuid)
    • 任务具体的执行逻辑

2、编程实现

task.py

# uuid是一个标准库
import uuid

# 基本任务对象
class Task:
    def __init__(self,func,*args,**kwargs):
        # 任务具体逻辑，通过函数引用传递进来
        self.callable=func
        self.id=uuid.uuid4()
        self.args=args
        self.kwargs=kwargs

    def __str__(self):
        return 'Task id:'+str(self.id)

def my_function():
    print('this is a task test.')

if __name__ == '__main__':
    task=Task(func=my_function())
    print(task)

五、线程池简介

1、什么是线程池

  • 线程池是存放多个线程的容器
  • CPU调度线程执行后不会销毁线程
  • 将线程放回线程池重复利用

2、为什么使用线程池

  • 线程是稀缺资源，不应该频繁创建和销毁
  • 架构解耦，线程创建和业务处理解耦，更加优雅
  • 线程池是使用线程的最佳实践

六、实现任务处理线程Process Thread

1、功能、必备属性

  • 任务处理线程需要不断的从任务队列里取任务执行
  • 任务处理线程需要有一个标记，标记线程什么时候应该停止
  • 实现任务处理线程
    • 基本属性(任务队列、标记)
    • 线程执行的逻辑
    • 线程停止(stop)

2、编程实现

pool.py

import threading
from operate_system.task import Task

# 任务处理线程
class ProcessThread(threading.Thread):
    def __init__(self,task_queue,*args,**kwargs):
        # 继承父类构造方法
        threading.Thread.__init__(self,*args,**kwargs)
        # 线程停止标记
        self.dismiss_flag=threading.Event()
        # 任务队列（处理线程不断从队列取出元素处理）
        self.task_queue=task_queue
        self.args=args
        self.kwargs=kwargs

    def run(self):
        while True:
            # 判断线程是否被要求停止
            if self.dismiss_flag.is_set():
                break
            task=self.task_queue.pop()
            if not isinstance(task,Task):
                continue
            # 执行task实际逻辑（是通过函数func（callable）调用引进）
            result=task.callable(*task.args,**task.kwargs)

    def dismiss(self):
        self.dismiss_flag.set()

    def stop(self):
        self.dismiss()

七、实现任务处理线程池Pool

1、线程池基本功能

  • 存放多个任务处理线程
  • 负责多个线程的启停
  • 管理向线程池提交的任务，下发给线程去执行

2、实现任务处理线程池

  • 基本属性
  • 提交任务(put,batch_put)
  • 线程启停（start，join）
  • 线程池大小（size）

3、编程实现

pool.py

class TaskTypeErrorException(Exception):
    pass

# 线程池
class ThreadPool:
    def __init__(self,size=0):
        if not size:
            size=psutil.cpu_count()*2
            # psutil.cpu_count()返回cpu核数
            self.pool=ThreadSafeQueue(size)
            # 任务队列
            self.task_queue=ThreadSafeQueue()
        for i in range(size):
            self.pool.put(ProcessThread(self.task_queue))
    # 启动线程池
    def start(self):
        for i in range(self.pool.size()):
            thread=self.pool.get(i)
            thread.start()
    # 停止线程池
    def join(self):
        for i in range(self.pool.size()):
            thread=self.pool.get(i)
            thread.stop()
        while self.pool.size():
            thread=self.pool.pop()
            thread.join()
    # 给线程池提交任务
    def put(self,item):
        if not isinstance(item,Task):
            raise TaskTypeErrorException()
        self.task_queue.put(item)
    # 批量提交
    def batch_put(self,item_list):
        if not isinstance(item_list,list):
            item_list=list(item_list)
        for item in item_list:
            self.put(item)
    #
    def size(self):
        return self.pool.size()

八、编写测试用例

编写测试用例，测试线程池是否有问题

  1. 初始化一个线程池
  2. 生成一系列任务
  3. 给线程池提交任务行

test.py

import time

from operate_system import task,pool
# 定义一个自己的任务
class SimpleTask(task.Task):
    def __init__(self,callable):
        super(SimpleTask,self).__init__(callable)
def process():
    print('This is a SimpleTask callable function.')
    time.sleep(1)
def test():
    # 1、初始化一个线程池
    test_pool=pool.ThreadPool()
    test_pool.start()
    # 2、生成一系列任务
    for i in range(10):
        simple_task=SimpleTask(process)
    # 3、给线程池提交任务执行
        test_pool.put(simple_task)


if __name__ == '__main__':
    test()

九、实现异步任务处理AsyncTask

  • 不知道任务什么时候执行
  • 不知道任务什么时候执行完成

使用条件变量解决

  • 给任务添加一个标记，任务完成后，则标记为已完成
  • 任务完成时，可直接获取任务运行结果
  • 任务未完成时，获取任务结果，会阻塞获取线程

实现AsyncTask

  • 设置运行结果(set_result)
  • 获取运行结果(get_result)

task.py

# 异步任务对象
class AsyncTask(Task):
    def __init__(self,func,*args,**kwargs):
        self.result=None
        self.condition=threading.Condition()
        super().__init__(func,*args,**kwargs)
    # 设置运行结果
    def set_result(self,result):
        self.condition.acquire()
        self.result=result
        self.condition.notify()
        self.condition.release()
    # 获取任务结果
    def get_result(self):
        self.condition.acquire()
        if not self.result:
            self.condition.wait()
        result=self.result
        self.condition.release()
        return result

pool.py中run()后面添加

result=task.callable(*task.args,**task.kwargs)
if isinstance(task,AsyncTask):
    task.set_result(result)

test.py中添加异步任务测试用例

# 异步任务测试用例
def test_async_task():
    def async_process():
        num=0
        for i in range(100):
            num += 1
        return num
    # 1、初始化一个线程池
    test_pool = pool.ThreadPool()
    test_pool.start()
    # 2、生成一系列任务
    for i in range(10):
        async_task = task.AsyncTask(async_process)
        # 3、给线程池提交任务执行
        test_pool.put(async_task)
        result=async_task.get_result()
        print('Get result:%d'%(result))

test.py中条件测试用例2

# 测试是否可以真正的等待(wait)
def test_async_task2():
    def async_process():
        num=0
        for i in range(100):
            num += 1
        time.sleep(1)
        return num
    # 1、初始化一个线程池
    test_pool = pool.ThreadPool()
    test_pool.start()
    # 2、生成一系列任务
    for i in range(10):
        async_task = task.AsyncTask(async_process)
        # 3、给线程池提交任务执行
        test_pool.put(async_task)
        print('get reusult in timestamp:%d'%time.time())
        result=async_task.get_result()
        print('Get result in timestamp:%d,result:%d'%(time.time(),result))

test.py中添加测试用例3

# 测试没有等待是否可以真正获取结果
def test_async_task3():
    def async_process():
        num=0
        for i in range(100):
            num += 1
        return num
    # 1、初始化一个线程池
    test_pool = pool.ThreadPool()
    test_pool.start()
    # 2、生成一系列任务
    for i in range(10):
        async_task = task.AsyncTask(async_process)
        # 3、给线程池提交任务执行
        test_pool.put(async_task)
        print('get reusult in timestamp:%d'%time.time())
        # 转而去处理其他线程，这里为处理sleep
        time.sleep(5)
        result=async_task.get_result()
        print('Get result in timestamp:%d,result:%d'%(time.time(),result))
An宁
关注
专栏目录
操作系统学习实战篇——实现支持异步任务的线程池
weixin_44776894的博客
07-27 151
Python同步原语 互斥锁 在每一次对临界资源进行读或写操作时，先加锁，操作完成之后再解锁。 Python互斥锁的使用： lock = threading.Lock() # 申请锁 lock.acquire() # 加锁 lock.release() # 解锁 条件变量 判断条件是否满足，一个线程在条件满足的时候执行；当条件不满足时睡眠，等待另一个线程满足条件将睡眠线程唤醒，使其继续执行下去。 Python条件变量的使用： condition=threading.Condition() .
基于liunx操作系统的线程池项目
09-03
这是初学者学习线程时，可以借鉴的一个项目，此项目实现的是关于目录名的拷贝。建立多个线性来实现的。
随笔之如何实现一个线程池
duoerbasilu
11-24 207
一 缘由： 最近因工作问题，需要实现一个简单的线程池，满足一下要求， 可伸缩，即一旦发现线程不够用，则可以动态增加线程。（至于缩减线程，这个可能难度比较大，暂时不考虑）。 支持超时任务。比如提交一个Task，可以设置5秒后执行，并且可以设置执行一次，还是每隔5秒执行。 基本上就是这两个要求。下面讨论下实现上的问题。 二 Windows平台 1 Windows平台实现一个线程池（不使用完成端...
Spring 异步线程池实例
Jadeon
09-04 643
Spring 异步线程池： 1、配置自定义线程池和启用异步 /** * @author 悟空 * @date 2020/9/3 */ @Configuration @EnableAsync public class AsyncConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { // 定义线程池 ThreadPoolTaskExecutor taskExecutor = n
线程池异步回掉的简单例子
anlc
11-16 409
本文是一个基于android activity请求网络数据情景，做的一个java的模拟网络异步请求的简单例子，包括了线程池和软引用的简单应用，如果有不对的地方，希望大家可以指正。 1.异步请求是为了执行耗时操作 2.线程池是为了并发多个请求 3.软引用是为了当回掉的类持有的对象被释放的时候，可以被垃圾回收及时处理（当然gc本身并不是及时回收的）好，下面开始贴代码，然后大概说两句IntelliJ
Linux：实现一个简单的线程池
ENSHADOWER的博客
08-07 354
线程池 一、定义：线程池是一种线程使用模式。 二、目的：线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 三、应用场景： 需要大量的线程来...
Django异步任务线程池实现原理
09-18
Django作为Python语言开发的一个高级Web框架，支持异步任务执行的能力，尤其在处理大规模数据库操作时，能够通过异步处理提升系统性能。而线程池技术，则是实现高效异步任务处理的重要手段之一。Django异步任务...
人工智能-项目实践-多任务-使用AsyncTask实现的多任务多线程下载的Demo，支持断点续传.zip
最新发布
01-04
AsyncTask是Android SDK提供的一种轻量级的异步处理机制，它可以在线程池中执行后台任务，然后在UI线程中更新结果，避免了直接操作UI导致的ANR（Application Not Responding）错误。在这个Demo中，开发者利用...
cpp-ThreadPoolLibrary使用现代C实现仅头文件的线程池库快速并且易于使用
08-16
线程池库是一种高效的任务调度工具，它允许多个任务并行执行，以优化系统资源的利用率。在本文中，我们将深入探讨一个基于C++的现代线程池库——cpp-ThreadPoolLibrary，这是一个轻量级且易于集成的库，只需要包含...
多线程的应用-异步任务线程池的简单实现
燕归来兮
07-12 193
原文链接 https://www.zhoutao123.com/page/book/java/category/ggccu5 更多文章欢迎访问 https://www.zhoutao123.com 对于服务端的应用而言，经常会出现比如定时任务，或者任务的异步执行，熟悉Java开发的开发者，经常会使用Executors类，其提供了4种不同的线程池： newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingle..
Executor线程池及其异步线程使用案例
pearkerChen
10-31 739
Executor框架的核心是线程池。线程池是指管理一组同构工作线程的资源池，具体可参考：https://www.cnblogs.com/timlearn/p/4023394.html https://blog.csdn.net/pozmckaoddb/article/details/51478017  https://www.cnblogs.com/zhaoyan001/p/7049627.h...
异步编程-线程池实现异步编程
yyy
08-13 981
如上代码确实可以在main函数所在线程获取到异步任务的执行结果，但是main线程必须以阻塞的代价来获取结果，在异步任务执行完毕前，main函数所在线程就不能做其他事情了，这显然不是我们所需要的，具体怎么解决这个问题，下章揭晓。上面代码0创建了一个线程池，这里我们设置线程池核心线程个数为当前物理机的CPU核数，最大线程个数为当前物理机CPU核数的2倍；设置线程池阻塞队列的大小为5；如上面代码所示，main函数所在线程只需要把两个任务提交到线程池后就可以做自己的事情了，具体两个任务是由线程池中的线程执行。...
springboot使用异步线程池执行自定义任务实例
qq_41358574的博客
10-13 336
1.介绍 在Spring中存在一个AsyncConfigurer接口，它是一个可以配置异步线程池的接口，因此只需要Java配置文件，实现AsyncConfigurer接口，实现getAsyncExecutor方法返回的线程池，这样Spring就会将使用这个线程池作为其异步调用的线程。为了使得异步可用，Spring还提供一个注解@EnableAsync，如果Java配置文件标注它，那么Spring就会开启异步可用，这样就可以使用注解@Async驱动Spring使用异步调用，下节我们会看到这样的实例。 　 异步
线程池使用示例（含源代码）
09-10
简单演示了如何使用线程池，可以再源代码的基础上进行修改进行更高级的操作，适合用于学习
操作系统 --进程的异步性
zty
01-15 4875
异步性是指进程以不可预知的速度向前推进。内存中的每个进程何时执行,何时暂停,以怎样的速度向前推进,每道程序总共需要多少时间才能完成等,都是不可预知的。 是程序并发执行时，程序之间的相互制约关系导致了并发程序这种“执行——暂停——执行”这种间断性的活动规律。 比如，当正在执行的进程提出某种资源请求时，如打印请求，而此时打印机正在为其他某进程打印，由于打印机属于临界资源，因此正在执行的进程必须等待，且...
Android代码-afinal框架实现图片的简单异步缓存加载.rar
08-02
Afinal是由陈昊开发的一个轻量级的Android ORM（对象关系映射）框架，它不仅提供了数据库操作的功能，还支持网络请求和图片加载。在图片加载方面，Afinal利用了异步处理和内存及磁盘缓存机制，有效提高了图片加载的...
线程池与异步任务
关注菜菜的后端私房菜，获取更多技术干货~
07-07 254
文章目录线程池与异步任务启动线程的几种方式线程池的创建线程池实现原理CompletableFuture 异步编排启动异步任务完成回调和异常感知异步任务完成时的处理两任务组合两组任务完成后要执行的任务两组任务任一任务完成后要执行的任务多任务组合项目整合异步任务1.编写线程池配置文件类2.导入依赖3.编写线程池组件4.编写异步任务核心代码 线程池与异步任务 启动线程的几种方式 在项目中只使用线程池的方式，这种池化技术节省资源开销，能够控制资源 池化技术:事先准备好一些资源,要使用就去池子里拿,用完了要还到池子
异步通信在生活中的例子_【分布式系统遨游】分布式通信
weixin_39524636的博客
01-06 341
为什么需要分布式通信我们之前在讲分布式资源调度的时候，把分布式系统中的各个节点与操作系统的进程做了类比。我们知道，操作系统的进程之间由于需要数据的交换，是需要进程通信机制的。那么同理，分布式系统之间同样需要通信。在业务层面，每个分布式系统一般都承载着一个微服务，所以，微服务之间也一定是需要通信的。比如，我们各条业务线均需要查询用户中心微服务的数据等等。我们常用的通信方式有三种：RPC、发布-订阅、...
计算机操作系统多线程多进程实例,请你说一下多进程、多线程，操作系统层面的差别和联系...
weixin_31093677的博客
07-27 319
参考回答：进程：进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简...
java 四种线程池实例
06-06
执行一个异步任务你还只是如下new Thread吗？是不是太low 了一点？ 我这里有四种线程池的案例轻松让你理解和使用线程池。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值