python 进程、线程 (二)

一、多线程与多进程的对比

python 进程、线程 (一)中简单的说过,CPython中的GIL使得同一时刻只能有一个线程运行,即并发执行。并且即使是多核CPU,GIL使得同一个进程中的多个线程也无法映射到多个CPU上运行,这么做最初是为了安全着想,慢慢的也成为了限制CPython性能的问题。
就像是一个线程想要执行,就必须得到GIL,否则就不能拿到CPU资源。但是也不是说一个线程在拿到CPU资源后就一劳永逸,在执行的过程中GIL可能会释放并被其他线程获取,所以说其它的线程会与本线程竞争CPU资源。
understand GIL:http://www.dabeaz.com/python/UnderstandingGIL.pdf中有关于GIL释放和GIL的概要。
多线程在python2中:当一个线程进行I/O的时候会释放锁,另外当ticks计数达到100(ticks可以看作是Python自身的一个计数器,也可对比着字节码指令理解,专门做用于GIL,每次释放后归零,这个计数可以通过 sys.setcheckinterval 来调整)。锁释放之后,就涉及到线程的调度,线程的锁进行,线程的切换。这是会消耗CPU资源,因此会造成程序性能问题和等待时延。特别是在CPU密集型代码时。
但是对于多进程,GIL就无法限制,多个进程可以再多个CPU上运行,充分利用多核优势。事情往往是相对的,虽然可以充分利用多核优势,但是进程之间的切换却比线程的切换代价更高。
所以选择多线程还是多进程,主要还是看怎样权衡代价,什么样的情况。

1、CPU密集代码

下面来利用斐波那契数列模拟CPU密集运算。

def fib(n):
    # 求斐波那契数列的第n个值
    if n<=2:
        return 1
    return fib(n-1)+fib(n-2)

<1>、多进程

打印第25到35个斐波那契数,并计算程序运行时间

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from concurrent.futures import ProcessPoolExecutor

def fib(n):
    if n<=2:
        return 1
    return fib(n-1)+fib(n-2)

if __name__ == "__main__":
    with ProcessPoolExecutor(3) as executor:  # 使用进程池控制  每次执行3个进程
        all_task = [executor.submit(fib, (num)) for num in range(25,35)]
        start_time = time.time()
        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

        print("last time is: {}".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
last time is: 4.457437038421631

输出结果,每次打印三个exe result,总重打印十个结果,多进程运行时间为4.45秒

<2>、多线程

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from concurrent.futures import ProcessPoolExecutor

def fib(n):
    if n<=2:
        return 1
    return fib(n-1)+fib(n-2)

if __name__ == "__main__":
    with ThreadPoolExecutor(3) as executor:  # 使用线程池控制  每次执行3个线程
        all_task = [executor.submit(fib, (num)) for num in range(25,35)]
        start_time = time.time()
        for future in as_completed(all_task):
            data = future.result()
            print("exe result: {}".format(data))

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

# 输出
exe result: 121393
exe result: 75025
exe result: 196418
exe result: 317811
exe result: 514229
exe result: 832040
exe result: 1346269
exe result: 2178309
exe result: 3524578
exe result: 5702887
last time is: 7.3467772006988525

最终程序运行时间为7.34秒

程序的执行之间与计算机的性能有关,每天计算机的执行时间都会有差异。从上述结果中看显然多线程比多进程要耗费时间。这就是因为对于密集代码(密集运算,循环语句等),tick计数很快达到100,GIL来回的释放竞争,线程之间频繁切换,所以对于密集代码的执行中,多线程性能不如对进程。

2、I/O密集代码

一个线程在I/O阻塞的时候,会释放GIL,挂起,然后其他的线程会竞争CPU资源,涉及到线程的切换,但是这种代价与较高时延的I/O来说是不足为道的。
下面用sleep函数模拟密集I/O

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

<1>、 多进程

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

if __name__ == "__main__":
    with ProcessPoolExecutor(5) 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("last time is: {}".format(time.time()-start_time))
#  输出
exe result: 2
exe result: 2
......(30个)
exe result: 2
exe result: 2
last time is: 12.412866353988647

每次打印5个结果,总共二十个打印结果,多进程运行时间为12.41秒

<2>、多线程

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

if __name__ == "__main__":
    with ThreadPoolExecutor(5) 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("last time is: {}".format(time.time()-start_time))

#  输出
exe result: 2
exe result: 2
......(30个)
exe result: 2
exe result: 2
last time is: 12.004231214523315

I/O密集多线程情况下,程序的性能较多进程有了略微的提高。IO密集型代码(文件处理、网络爬虫等),多线程能够有效提升效率(单线程下有IO操作会进行IO等待,造成不必要的时间浪费,而开启多线程能在线程A等待时,自动切换到线程B,可以不浪费CPU的资源,从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好

3、总结

  • CPU密集型代码(各种循环处理、计数等等),多线程性能不如多进程。
  • I/O密集型代码(文件处理、网络爬虫等),多进程不如多线程。

原文地址:https://www.cnblogs.com/welan/p/10003312.html

时间: 2024-11-06 09:22:15

python 进程、线程 (二)的相关文章

python/进程线程的总结

python/进程线程的总结 一.进程和线程的描述: 进程:最小的资源管理单位 线程:最小的执行单位 执行一个进程时就默认执行一个线程(主线程) 进程和线程的工作方式: 串行: 假如共有A.B.C任务, 串行的执行流程是第一个执行A任务,A任务执行完毕后再执行B任务,B任务执行完毕后最后执行C任务. 并发: 假如共有A.B.C任务,并行的执行流程是执行A任务一段时间,切换成B任务执行一段时间,在切换到C任务,直到A.B.C三个任务都执行完毕. 并行: 假如共有A.B.C任务,并发的执行流程是同一

python进程线程

一.背景知识 理论基础 1.操作系统的作用: (1)隐藏丑陋复杂的硬件接口,提供良好的抽象接口 (2)管理.调度进程,并且将多个进程对硬件的竞争变得有序 2.多道技术: (1)产生背景:针对单核,实现并发(现在的主机一般是多核,name每个核都会利用多道技术,但是核与核之间没有使用多道技术切换这么一说,一个程序IO阻塞,会等到IO结束再重新调度) (2)时间上的复用(复用一个cpu的时间片)+空间上的复用(如内存中同时有多道程序) 二.进程 1.什么是进程 进程:正在进行的一个过程或者说一个任务

python 进程 线程 协程

并发与并行:并行是指两个或者多个事件在同一时刻发生:而并发是指两个或多个事件在同一时间间隔内发生.在单核CPU下的多线程其实都只是并发,不是并行. 进程是系统资源分配的最小单位,进程的出现是为了更好的利用CPU资源使到并发成为可能.进程由操作系统调度. 线程的出现是为了降低上下文切换的消耗,提高系统的并发性,并突破一个进程只能干一样事的缺陷,使到进程内并发成为可能.线程共享进程的大部分资源,并参与CPU的调度, 当然线程自己也是拥有自己的资源的,例如,栈,寄存器等等.线程由操作系统调度. 协程通

python进程/线程/协成

1.谈谈对多进程多线程以及协成的理解 进程:一个运行的程序(代码)就是一个进程,没有运行的代码叫做程序,进程是系统资源分配的最小单位,进程拥有自己独立的内存空间,所以进程间数据不共享,开销大 线程:调度执行的最小单位,也叫执行路径,不能独立存在,必须依赖进程存在,一个进程至少有一个线程,叫主线程,而多个线程共享内存(数据共享,共享全局变量),从而极大地提高了程序的运行效率. 协成:是一种用户太的轻量级线程,协成的调度完全由用户控制,协成拥有自己的寄存器上下文和栈.协成调度切换时,将寄存器上下文和

帮你搞懂Python进程,线程与协程

本文参考原文-http://bjbsair.com/2020-03-22/tech-info/4425/在操作系统中,每一个独立运行的程序,都占有 操作系统 分配的资源,这些程序中间互不干涉,都只负责运行自己的程序代码,这就是进程. 但是当操作系统频繁的创建销毁进程时,大量的系统资源被浪费在创建和销毁的过程中.而随着多核心 cpu 的出现,线程也逐渐代替了进程,成为了操作系统 可以独立运行的基本单位. 当进程不是多线程程序时,存在于进程当中的唯一线程,便是进程本身运行的代码块. 而当多线程出现在

python 进程/线程/协程 测试

# Author: yeshengbao # -- coding: utf-8 -- # @Time : 2018/5/24 21:38 # 进程:如一个人拥有分身(分数数最好为cpu核心数)几乎同时进行做工# 线程:如这个人正在烧开水,但同时又可以在烧水时间内去吃饭,和扫地,这时线程就会对其随机选择,可能还会出现地还没扫完,水就开了,但他还会扫地{这就可能出现数据丢失}..# 协程:这个一个比线程更小的线程非常相似,但他在执行任务时,已经被规划好了,不会就行额外的时间浪费,创建时更省资源 im

python -- 进程线程专题

要让Python程序实现多进程(multiprocessing),我们先了解操作系统的相关知识. Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊.普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回. 子进程永远返回0,而父进程返回子进程的ID.这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用get

python 进程线程简单理解

简单的理解 1.线程:最小的执行单元:进程:最小的资源单元 2.一个程序至少有一个进程,一个进程至少有一个线程(线程可以理解为线程的容器) 3.进程在执行过程中拥有独立的内存单元,而多个线程共享内存 4.每一个独立的线程都有 程序的入口,顺序执行的序列和程序出口,但是线程不能独立执行,必须由应用程序提供多个线程执行控制 5.进程是系统进行资源分配和调度的一个独立单元 多线程的代码开启 import threading import time def sing(): print("begin to

Python - 进程/线程相关整理

进程池 Pool #检测url状态 from multiprocessing.dummy import Pool as ThreadPool import requests siteList = [] with open("all1.txt") as f: for line in f.readlines(): siteList.append(line) pool = ThreadPool() results = pool.map(requests.get, siteList) for

python进程|线程|协程

进程(Process) 1)进程就是正在运行的程序,它是操作系统中,资源分配的最小单位 (1)资源分配:分配的是cpu和内存等物理资源 (2)进程号是进程的唯一标识 2)同一个程序执行两次之后是两个进程 3)进程和进程之间的关系: 数据彼此隔离,通过socket通信 获取进程id import os res = os.getpid() # 获取当前进行id (当前子进程) print(res) res = os.getppid() # 获取父进程id print(res) # result "&