Python - IO密集型任务、计算密集型任务,及多线程、多进程

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/SecondLieutenant/article/details/79396984

IO密集型任务,是指磁盘IO、网络IO占主要的任务,计算量很小。比如请求网页、读写文件等。
在Python中可利用sleep达到IO密集型任务的目的。

计算密集型任务,是指CPU计算占主要的任务,CPU一直处于满负荷状态。比如在很大的列表中查找元素(当然这不合理),复杂的加减乘除等。

Python中比较常见的并发方式主要有两种:多线程和多进程。当然还有协程,这里不做介绍。
1、多线程,即在一个进程中启动多个线程执行任务。一般来说使用多线程可以达到并行的目的。
    但由于Python中使用了全局解释锁GIL的概念,导致Python中的多线程并不是并行执行,而是“交替执行”。
    所以Python中的多线程适合IO密集型任务,而不适合计算密集型任务。
    Python提供两组多线程接口,
        一是thread模块_thread,提供低等级接口。
        二是threading模块,提供更容易使用的基于对象的接口,可继承Thread对象来实现线程,
        此外其还提供了其它线程相关的对象,例如 Timer,Lock 等。

2、多进程
    由于Python中GIL的原因,对于计算密集型任务,Python下比较好的并行方式是使用多进程,
    因为可有效的使用CPU资源,当然同一时间执行的进程数量取决电脑的CPU核心数。
    
    Python中的多进程模块为 mutliprocess 模块,提供了很多容易使用的基于对象的接口。
    另外它提供了封装好的管道和队列,可以方便的在进程间传递消息。Python还提供了进程池 Pool 对象,可以方便的管理和控制线程。

实例:Python中的多线程、多进程如何应对IO密集型任务、计算密集型任务

from multiprocessing import Process , Queue , cpu_count
import time
from threading import Thread

# 定义全局变量Queue
g_queue = Queue()
# 定义一个队列,并定义初始化队列的函数
def init_queue():
    print("init g_queue start")
    while not g_queue.empty():
        g_queue.get()
    for _index in range(10):
        g_queue.put(_index)
    print("init g_queue end")
    return

# 定义IO密集型任务和计算密集型任务,分别从队列中获取任务数据
# 定义一个IO密集型任务:利用time.sleep()
def task_io(task_id):
    print("IOTask[%s] start" % task_id)
    while not g_queue.empty():
        time.sleep(1)
        try:
            data = g_queue.get(block=True, timeout=1)
            print("IOTask[%s] get data: %s" % (task_id, data))
        except Exception as excep:
            print("IOTask[%s] error: %s" % (task_id, str(excep)))
    print("IOTask[%s] end" % task_id)
    return

g_search_list = list(range(10000))
# 定义一个计算密集型任务:利用一些复杂加减乘除、列表查找等
def task_cpu(task_id):
    print("CPUTask[%s] start" % task_id)
    while not g_queue.empty():
        count = 0
        for i in range(10000):
            count += pow(3*2, 3*2) if i in g_search_list else 0
        try:
            data = g_queue.get(block=True, timeout=1)
            print("CPUTask[%s] get data: %s" % (task_id, data))
        except Exception as excep:
            print("CPUTask[%s] error: %s" % (task_id, str(excep)))
    print("CPUTask[%s] end" % task_id)
    return task_id

if __name__ == '__main__':
    print("cpu count:", cpu_count(), "\n")

    print("========== 直接执行IO密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    task_io(0)
    print("结束:", time.time() - time_0, "\n")

    print("========== 多线程执行IO密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    thread_list = [Thread(target=task_io, args=(i,)) for i in range(5)]
    for t in thread_list:
        t.start()
    for t in thread_list:
        if t.is_alive():
            t.join()
    print("结束:", time.time() - time_0, "\n")

    print("========== 多进程执行IO密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    process_list = [Process(target=task_io, args=(i,)) for i in range(cpu_count())]
    for p in process_list:
        p.start()
    for p in process_list:
        if p.is_alive():
            p.join()
    print("结束:", time.time() - time_0, "\n")

    print("========== 直接执行CPU密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    task_cpu(0)
    print("结束:", time.time() - time_0, "\n")

    print("========== 多线程执行CPU密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    thread_list = [Thread(target=task_cpu, args=(i,)) for i in range(5)]
    for t in thread_list:
        t.start()
    for t in thread_list:
        if t.is_alive():
            t.join()
    print("结束:", time.time() - time_0, "\n")

    print("========== 多进程执行cpu密集型任务 ==========")
    init_queue()
    time_0 = time.time()
    process_list = [Process(target=task_cpu, args=(i,)) for i in range(cpu_count())]
    for p in process_list:
        p.start()
    for p in process_list:
        if p.is_alive():
            p.join()
    print("结束:", time.time() - time_0, "\n")


'''
cpu count: 4

========== 直接执行IO密集型任务 ==========
init g_queue start
init g_queue end
IOTask[0] start
IOTask[0] end
结束: 0.0

========== 多线程执行IO密集型任务 ==========
init g_queue start
init g_queue end
IOTask[0] start
IOTask[1] start
IOTask[2] start
IOTask[3] start
IOTask[4] start
IOTask[1] get data: 0
IOTask[0] get data: 1
IOTask[3] get data: 2
IOTask[4] get data: 3
IOTask[2] get data: 4
IOTask[0] get data: 6
IOTask[1] get data: 5
IOTask[2] get data: 7
IOTask[4] get data: 8
IOTask[3] get data: 9
IOTask[1] get data: 0
IOTask[0] get data: 1
IOTask[2] get data: 2
IOTask[4] get data: 3
IOTask[3] get data: 4
IOTask[0] get data: 5
IOTask[1] get data: 6
IOTask[2] get data: 7
IOTask[3] get data: 8
IOTask[4] get data: 9
IOTask[4] end
IOTask[0] error:
IOTask[1] error:
IOTask[0] end
IOTask[1] end
IOTask[2] error:
IOTask[3] error:
IOTask[2] end
IOTask[3] end
结束: 6.001343488693237

========== 多进程执行IO密集型任务 ==========
init g_queue start
init g_queue end
IOTask[0] start
IOTask[0] end
IOTask[1] start
IOTask[1] end
IOTask[2] start
IOTask[2] end
IOTask[3] start
IOTask[3] end
结束: 0.4450252056121826

========== 直接执行CPU密集型任务 ==========
init g_queue start
init g_queue end
CPUTask[0] start
CPUTask[0] end
结束: 0.0

========== 多线程执行CPU密集型任务 ==========
init g_queue start
init g_queue end
CPUTask[0] start
CPUTask[1] start
CPUTask[2] start
CPUTask[3] start
CPUTask[4] start
CPUTask[1] get data: 0
CPUTask[2] get data: 1
CPUTask[1] get data: 2
CPUTask[3] get data: 3
CPUTask[0] get data: 4
CPUTask[4] get data: 5
CPUTask[2] get data: 6
CPUTask[1] get data: 7
CPUTask[2] get data: 8
CPUTask[3] get data: 9
CPUTask[3] end
CPUTask[1] error:
CPUTask[1] end
CPUTask[4] error:
CPUTask[4] end
CPUTask[0] error:
CPUTask[0] end
CPUTask[2] error:
CPUTask[2] end
结束: 12.043688774108887

========== 多进程执行cpu密集型任务 ==========
init g_queue start
init g_queue end
CPUTask[0] start
CPUTask[0] end
CPUTask[1] start
CPUTask[1] end
CPUTask[2] start
CPUTask[2] end
CPUTask[3] start
CPUTask[3] end
结束: 0.3960227966308594
'''

 

 

阅读更多

没有更多推荐了,返回首页