python 3.x 多线程与多进程对比

多线程与多进程对比

• 由于在python中有一把GIL锁,所以说对于某一些任务来说,这里主要指的是耗cpu的操作,因为有一把GIL锁的存在,所以说我们python中的多线程实际上是无法充分的利用多核的优势,
  所以说对于某些耗cpu的操作来说,我们用多线程编程就无法达到一个并行的操作,所以python中也提供了多进程编程,多进程编程就可以充分的利用多个cpu并发的这么一个特性,去提高我们的运行效率,所以说多cpu的操作,用多进程编程.
• 对于IO操作来说,我们往往的瓶颈不在于cpu,所以使用多线程编程.IO操作也可使用多进程编程,但是对于操作系统来说进程间的切换代价要高于线程的切换.当我们同时运行几十个线程,对于操作系统来说,线程的切换性能是要比进程间切换性能要高的,
  所以说在特定的情况下,能够使用多线程的情况下尽量使用多线程
• 举例说明:
  • 对于耗费cpu的操作,主要指的是计算,计算类型的操作都是耗cpu的(比如数学运算,图形处理.).
    显卡里的GPU的运算速度是高于CPU的(对于图形计算来说,多进程是比多线程高的),所以说对于耗费cpu的操作,多进程优于多线程　　
• 多线程的稳定性高于多进程
• 注意:
  • 在windows系统下使用多进程编程的时候,不管使用ProcessPoolExecutor还是使用MultiProcessPoolExecutor来进行多进程编程,多进程的执行代码没有放在if __name__ == '__main__':语句下,　　
  • 会抛异常.　　
    • A process in the process pool was terminated abruptly while the future was running or pending.(在将来运行或挂起时，进程池中的进程突然终止)。　　　　
  • 在Linux下是没有这个问题的,只有在windows下才需要将多进程编程的代码写在if __name__ == '__main__':语句下.　　

"""
斐波拉契计算是耗cpu的.来看看斐波拉契计算在多线程和多进程的一个表现.

多线程下的斐波拉契的表现
"""

import time
from concurrent.futures import ThreadPoolExecutor, as_completed


def fib(n):
    """斐波拉契"""
    if n <= 2:
        return 1

    return fib(n - 1) + fib(n - 2)


if __name__ == '__main__':

    # 多线程编程,ThreadPoolExecutor继承Executor,而Executor类中实现魔法函数__enter__()和__exit__()
    #     def __exit__(self, exc_type, exc_val, exc_tb):
    #         self.shutdown(wait=True) --> 关闭线程池
    #         return False
    # --------------------------------------------------------------------------------------
    # 1.创建线程池执行者
    with ThreadPoolExecutor(3) as executor:
        # 2.提交所有任务(需要执行的函数fib以及函数所需要的参数num),返回所有任务的列表.
        all_task = [executor.submit(fib, num) for num in range(25, 35)]

        start_time = time.time()

        # 3.判断任务是否执行完成,获取执行完成的任务的结果.
        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

        # 运行时间13.77秒
        print("run time: {}".format(time.time() - start_time))

"""
输出结果:
    exe result: 75025
    exe result: 121393
    exe result: 196418
    exe result: 317811
    exe result: 514229
    exe result: 832040
    exe result: 1346269
    exe result: 2178309
    exe result: 3524578
    exe result: 5702887
    run time: 13.77378797531128
"""

 

 

"""
斐波拉契计算是耗cpu的.来看看斐波拉契计算在多线程和多进程的一个表现.
多进程下的斐波拉契的表现
"""


import time
from concurrent.futures import ProcessPoolExecutor, as_completed


def fib(n):
    """斐波拉契"""
    if n <= 2:
        return 1

    return fib(n - 1) + fib(n - 2)


if __name__ == '__main__':
    # 1.创建进程池执行者
    with ProcessPoolExecutor(3) as executor:
        # 2.提交所有任务(需要执行的函数fib以及函数所需要的参数num),返回所有任务的列表.
        all_task = [executor.submit(fib, num) for num in range(25, 35)]

        start_time = time.time()

        # 3.判断任务是否执行完成,获取执行完成的任务的结果.
        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

        # 运行时间3.15秒
        print("run time: {}".format(time.time() - start_time))

"""
输出结果:
    exe result: 75025
    exe result: 121393
    exe result: 196418
    exe result: 317811
    exe result: 514229
    exe result: 832040
    exe result: 1346269
    exe result: 2178309
    exe result: 3524578
    exe result: 5702887
    run time: 3.1521804332733154

通过多线程与多进程执行同样的任务,执行的时间相差很的大
得出结论:
    对于耗费cpu的操作,多进程优于多线程
"""

 

 

"""
对于IO操作来说,多线程优于多进程

多线程对IO操作
"""

import time
from concurrent.futures import ThreadPoolExecutor, as_completed


# 用sleep来模拟IO操作
def random_sleep(n):
    time.sleep(n)
    return n


if __name__ == '__main__':
    with ThreadPoolExecutor(3) as executor:
        # 每次sleep 2秒,执行30次.
        all_task = [executor.submit(random_sleep, num) for num in [2] * 30]

        start_time = time.time()

        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

    print("run time: {}".format(time.time() - start_time))

"""
输出结果:
    输出30个 : exe result: 2
    
    run time: 20.00214409828186秒
"""

 

 

"""
对于IO操作来说,多线程优于多进程

多进程对IO操作
"""
import time
from concurrent.futures import ProcessPoolExecutor, as_completed


def random_sleep(n):
    time.sleep(n)
    return n


if __name__ == '__main__':
    with ProcessPoolExecutor(3) as executor:
        all_task = [executor.submit(random_sleep, num) for num in [2] * 30]

        start_time = time.time()

        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

        print("run time: {}".format(time.time() - start_time))

"""
输出结果:
    输出30个 : exe result: 2
    
    run time: 20.598177909851074秒
"""

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

********