精华内容
下载资源
问答
  • 2020-09-15 23:04:57

    从单线程应用到多线程应用带来的不仅仅是好处。也会带来开销。不要仅仅在一个应用中使用多线程仅仅是因为你能够(会)使用多线程。你应该能确定使用多线程带来的好处要远远多于它带来的花销。如果不能够确定,那么请尝试测量应用的性能和响应性,不仅仅是猜测。

    更复杂的设计

    尽管多线程应用的某些部分要比单线程应用更加简单,但是应用的另一些部分会变得更加复杂。当一个多线程应用访问共享数据时要特别注意。线程的交互一点也不简单。错误总是在不正确的线程同步中产生,而且很难发现、重现、修复。

    线程切换开销

    当一个cpu从一个线程切换到另一个线程时,cpu需要保存当前线程的本地数据,程序当前的指针等,然后加载下一个等待执行的线程的本地数据,程序指针等。这种切换被称之为上下文切换。cpu从执行一个线程切换去执行另一个线程。

    上下文切换需要花费很多资源。除非必要,你不要去切换上下文。

    你能够读更多的信息关于上下文在维基百科上面。

    增加的资源消耗

    为了启动一个线程需要消耗一些计算机的资源。而且一个线程cpu时间(?)需要一些内存来存储它的本地的栈。它也会在操作系统中占据一些资源来管理线程。尝试创建一个拥有100个线程的程序,每一个线程什么都不做,仅仅是等待,然后看看当这个应用运行的时候占据了多少内存。

    更多相关内容
  • 为什么线程切换开销

    千次阅读 2020-12-22 17:01:49
    线程切换开销 我们都知道,线程切换会带来开销,如果频繁进行线程切换,所造成的开销是相当可观的。那么为什么线程切换会有开销呢,有哪些开销呢?这里涉及几个概念:CPU上下文切换、线程上下文切换、特权模式...

    1. Unix/Linux的体系架构

    从宏观上来看,Linux操作系统的体系架构分为用户态和内核态(或者用户空间和内核)。内核从本质上看是一种软件,它控制计算机的硬件资源,并提供上层应用程序运行的环境。用户态即上层应用程序的活动空间,应用程序的执行必须依托于内核提供的资源,包括CPU资源、存储资源、I/O资源等。为了使上层应用能够访问到这些资源,内核必须为上层应用提供访问的接口:即系统调用。

    系统调用是操作系统的最小功能单位,每个系统调用都会实现一个简单的操作。在应用程序中可以调用所需的系统调用来完成任务,但是对于复杂的任务,需要频繁地调用大量的系统调用,这势必会增加程序员的负担。库函数正是为了将程序员从复杂的细节中解脱出来而提出的一种有效方法。它实现对系统调用的封装,将简单的业务逻辑接口呈现给用户,方便用户调用。这样的一种组成方式极大增强了程序设计的灵活性,对于简单的操作,我们可以直接调用系统调用来访问资源,对于复杂操作,我们借助于库函数来实现。

    2. 用户态和内核态

    内核态和用户态的概念,是操作系统为了有效实现CPU的权限分级和数据隔离而提出的。因为系统的资源是有限的,如果用户都去随意地访问和使用这些资源,会造成冲突和混乱。为了使得程序在系统上正常运行,Unix/Linux对不同的操作赋予不同的权限等级,Linux操作系统中主要采用了0和3两个特权级,分别对应内核态和用户态。运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制,而运行在内核态的进程则可以执行任何操作并且在资源的使用上没有限制。在用户态运行的程序,在运行过程中,一些操作需要内核的权限才能执行,这是就会涉及到一个从用户态切换到内核态的过程。

    3. 线程切换的开销

    我们都知道,线程切换会带来开销,如果频繁进行线程切换,所造成的开销是相当可观的。那么为什么线程切换会有开销呢,有哪些开销呢?这里涉及几个概念:CPU上下文切换、线程上下文切换、特权模式切换(内核态和用户态的互相转换)。

    CPU上下文切换

    在多任务操作系统中,对于一个CPU而言,它并不是一直为一个任务服务直到任务结束的,而是在不同的任务之间切换,使得多个任务轮流使用CPU。而在每个任务运行前,CPU都需要知道任务从哪里加载、此时的状态、从哪里开始运行,也就是说,需要系统事先帮它设置好CPU寄存器程序计数器,这些内容就是CPU上下文

    稍微详细描述一下,CPU上下文切换可以认为是内核在 CPU 上对于进程(包括线程)进行以下的活动:(1)挂起一个进程,将这个进程的CPU 上下文存储于内存中的某处,(2)在内存中检索下一个进程的上下文并将其在 CPU 的寄存器中恢复,(3)跳转到程序计数器所指向的位置(即跳转到进程被中断时的代码行),以恢复该进程。

    CPU上下文切换的分为几个不同的场景:进程上下文切换,线程上下文切换,中断上下文切换

    线程上下文切换

    当从一个线程切换到另一个线程时,不仅会发生线程上下文切换,还会发生特权模式切换。

    首先,既然是线程切换,那么一定涉及线程状态的保存和恢复,包括寄存器、栈等私有数据。另外,线程的调度是需要内核级别的权限的(操作CPU和内存),也就是说线程的调度工作是在内核态完成的,因此会有一个从用户态到内核态的切换。而且,不管是线程本身的切换还是特权模式的切换,都要进行CPU的上下文切换。本质上都是从“一段程序”切换到了“另一段程序”,都要设置相应的CPU上下文。要明确一个问题,那就是内核也是有代码的,只是这些代码的机密性比较高,我们用户态无法访问。(要理清这几个概念的关系)

    总结来说,线程切换过程包括:线程上下文的保存和恢复,用户态和内核态的转换,CPU上下文的切换,这些工作都需要CPU去完成,是一笔不小的开销

    参考文章

    linux体系架构

    CPU上下文切换详解

    深入理解CPU上下文切换

    Linux | 用户态和内核态的切换耗费时间的原因

    怎样去理解Linux用户态和内核态?

    写给Java程序员看的,CPU 上下文切换、用户态、内核态、进程与线程上下文切换(转)

    展开全文
  • 进程/线程切换究竟需要多少开销

    千次阅读 2020-11-29 08:00:00
    进程是我们开发同学非常熟悉的概念,我们可能也听说过进程上下文切换开销。那么今天让我们来思考一个问题,究竟一次进程上下文切换会吃掉多少CPU时间呢?线程据说比进程轻量,它的上下文切换会比进...

    进程是我们开发同学非常熟悉的概念,我们可能也听说过进程上下文切换开销。那么今天让我们来思考一个问题,究竟一次进程上下文切换会吃掉多少CPU时间呢?线程据说比进程轻量,它的上下文切换会比进程切换节约很多CPU时间吗?带着这些疑问,让我们进入正题。

    1

    进程以及进程切换

    进程是操作系统的伟大发明之一,对应用程序屏蔽了CPU调度、内存管理等硬件细节,而抽象出一个进程的概念,让应用程序专心于实现自己的业务逻辑既可,而且在有限的CPU上可以“同时”进行许多个任务。但是它为用户带来方便的同时,也引入了一些额外的开销。如下图,在进程运行中间的时间里,虽然CPU也在忙于干活,但是却没有完成任何的用户工作,这就是进程机制带来的额外开销。

    在进程A切换到进程B的过程中,先保存A进程的上下文,以便于等A恢复运行的时候,能够知道A进程的下一条指令是啥。然后将要运行的B进程的上下文恢复到寄存器中。这个过程被称为上下文切换。上下文切换开销在进程不多、切换不频繁的应用场景下问题不大。但是现在Linux操作系统被用到了高并发的网络程序后端服务器。在单机支持成千上万个用户请求的时候,这个开销就得拿出来说道说道了。因为用户进程在请求Redis、Mysql数据等网络IO阻塞掉的时候,或者在进程时间片到了,都会引发上下文切换。

    2

    一次简单的进程切换开销测试

    废话不多说,我们先用个实验测试一下,到底一次上下文切换需要多长的CPU时间!实验方法是创建两个进程并在它们之间传送一个令牌。其中一个进程在读取令牌时就会引起阻塞。另一个进程发送令牌后等待其返回时也处于阻塞状态。如此往返传送一定的次数,然后统计他们的平均单次切换时间开销。编译、运行

    # gcc main.c -o main
    # ./main./main
    Before Context Switch Time1565352257 s, 774767 us
    After Context SWitch Time1565352257 s, 842852 us
    
    

    每次执行的时间会有差异,多次运行后平均每次上下文切换耗时3.5us左右。当然了这个数字因机器而异,而且建议在实机上测试。

    前文我们测试系统调用的时候,最低值是200ns。可见,上下文切换开销要比系统调用的开销要大。系统调用只是在进程内将用户态切换到内核态,然后再切回来,而上下文切换可是直接从进程A切换到了进程B。显然这个上下文切换需要完成的工作量更大。

    3

    进程切换开销分析

    那么上下文切换的时候,CPU的开销都具体有哪些呢?开销分成两种,一种是直接开销、一种是间接开销。

    直接开销就是在切换时,cpu必须做的事情,包括:

    1、切换页表全局目录

    2、切换内核态堆栈

    3、切换硬件上下文(进程恢复前,必须装入寄存器的数据统称为硬件上下文)

    • ip(instruction pointer):指向当前执行指令的下一条指令

    • bp(base pointer): 用于存放执行中的函数对应的栈帧的栈底地址

    • sp(stack poinger): 用于存放执行中的函数对应的栈帧的栈顶地址

    • cr3:页目录基址寄存器,保存页目录表的物理地址

    • ......

    4、刷新TLB

    5、系统调度器的代码执行

    间接开销主要指的是虽然切换到一个新进程后,由于各种缓存并不热,速度运行会慢一些。如果进程始终都在一个CPU上调度还好一些,如果跨CPU的话,之前热起来的TLB、L1、L2、L3因为运行的进程已经变了,所以以局部性原理cache起来的代码、数据也都没有用了,导致新进程穿透到内存的IO会变多。其实我们上面的实验并没有很好地测量到这种情况,所以实际的上下文切换开销可能比3.5us要大。

    想了解更详细操作过程的同学请参考《深入理解Linux内核》中的第三章和第九章。

    4

    一个更为专业的测试工具-lmbench

    lmbench用于评价系统综合性能的多平台开源benchmark,能够测试包括文档读写、内存操作、进程创建销毁开销、网络等性能。使用方法简单,但就是跑有点慢,感兴趣的同学可以自己试一试。

    这个工具的优势是是进行了多组实验,每组2个进程、8个、16个。每个进程使用的数据大小也在变,充分模拟cache miss造成的影响。我用他测了一下结果如下(下图需要横向滚动查看完全):

    -------------------------------------------------------------------------
    Host                 OS  2p/0K 2p/16K 2p/64K 8p/16K 8p/64K 16p/16K 16p/64K
                             ctxsw  ctxsw  ctxsw ctxsw  ctxsw   ctxsw   ctxsw
    --------- ------------- ------ ------ ------ ------ ------ ------- -------
    bjzw_46_7 Linux 2.6.32- 2.7800 2.7800 2.7000 4.3800 4.0400 4.75000 5.48000
    
    

    lmbench显示的进程上下文切换耗时从2.7us到5.48之间。

    5

    线程上下文切换耗时

    前面我们测试了进程上下文切换的开销,我们再继续在Linux测试一下线程。看看究竟比进程能不能快一些,快的话能快多少。

    在Linux下其实本并没有线程,只是为了迎合开发者口味,搞了个轻量级进程出来就叫做了线程。轻量级进程和进程一样,都有自己独立的task_struct进程描述符,也都有自己独立的pid。从操作系统视角看,调度上和进程没有什么区别,都是在等待队列的双向链表里选择一个task_struct切到运行态而已。只不过轻量级进程和普通进程的区别是可以共享同一内存地址空间、代码段、全局变量、同一打开文件集合而已。

    同一进程下的线程之所有getpid()看到的pid是一样的,其实task_struct里还有一个tgid字段。对于多线程程序来说,getpid()系统调用获取的实际上是这个tgid,因此隶属同一进程的多线程看起来PID相同。

    我们用一个实验来进行另外一个测试。其原理和进程测试差不多,创建了20个线程,在线程之间通过管道来传递信号。接到信号就唤醒,然后再传递信号给下一个线程,自己睡眠。这个实验里单独考虑了给管道传递信号的额外开销,并在第一步就统计了出来。

    # gcc -lpthread main.c -o main
    0.508250
    4.363495
    
    

    每次实验结果会有一些差异,上面的结果是取了多次的结果之后然后平均的,大约每次线程切换开销大约是3.8us左右。从上下文切换的耗时上来看,Linux线程(轻量级进程)其实和进程差别不太大。

    6

    Linux相关命令

    既然我们知道了上下文切换比较的消耗CPU时间,那么我们通过什么工具可以查看一下Linux里究竟在发生多少切换呢?如果上下文切换已经影响到了系统整体性能,我们有没有办法把有问题的进程揪出来,并把它优化掉呢?(下图需要横向滚动查看完全)

    # vmstat 1
    procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
     r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
     2  0      0 595504   5724 190884    0    0   295   297    0    0 14  6 75  0  4
     5  0      0 593016   5732 193288    0    0     0    92 19889 29104 20  6 67  0  7
     3  0      0 591292   5732 195476    0    0     0     0 20151 28487 20  6 66  0  8
     4  0      0 589296   5732 196800    0    0   116   384 19326 27693 20  7 67  0  7
     4  0      0 586956   5740 199496    0    0   216    24 18321 24018 22  8 62  0  8
    
    

    或者是

    # sar -w 1
    proc/s
         Total number of tasks created per second.
    cswch/s
         Total number of context switches per second.
    11:19:20 AM    proc/s   cswch/s
    11:19:21 AM    110.28  23468.22
    11:19:22 AM    128.85  33910.58
    11:19:23 AM     47.52  40733.66
    11:19:24 AM     35.85  30972.64
    11:19:25 AM     47.62  24951.43
    11:19:26 AM     47.52  42950.50
    ......
    
    

    上图的环境是一台生产环境机器,配置是8核8G的KVM虚机,环境是在nginx+fpm的,fpm数量为1000,平均每秒处理的用户接口请求大约100左右。其中cs列表示的就是在1s内系统发生的上下文切换次数,大约1s切换次数都达到4W次了。粗略估算一下,每核大约每秒需要切换5K次,则1s内需要花将近20ms在上下文切换上。要知道这是虚机,本身在虚拟化上还会有一些额外开销,而且还要真正消耗CPU在用户接口逻辑处理、系统调用内核逻辑处理、以及网络连接的处理以及软中断,所以20ms的开销实际上不低了。

    那么进一步,我们看下到底是哪些进程导致了频繁的上下文切换?(下图可能需要横向滚动查看完全)

    # pidstat -w 1
    11:07:56 AM       PID   cswch/s nvcswch/s  Command
    11:07:56 AM     32316      4.00      0.00  php-fpm
    11:07:56 AM     32508    160.00     34.00  php-fpm
    11:07:56 AM     32726    131.00      8.00  php-fpm
    ......
    
    

    由于fpm是同步阻塞的模式,每当请求Redis、Memcache、Mysql的时候就会阻塞导致cswch/s自愿上下文切换,而只有时间片到了之后才会触发nvcswch/s非自愿切换。可见fpm进程大部分的切换都是自愿的、非自愿的比较少。

    如果想查看具体某个进程的上下文切换总情况,可以在/proc接口下直接看,不过这个是总值。

    grep ctxt /proc/32583/status
    voluntary_ctxt_switches:        573066
    nonvoluntary_ctxt_switches:     89260
    

    7

    本文结论

    上下文切换具体做哪些事情我们没有必要记,只需要记住一个结论既可,测得作者开发机上下文切换的开销大约是2.7-5.48us左右,你自己的机器可以用我提供的代码或工具进行一番测试。

    lmbench相对更准确一些,因为考虑了切换后Cache miss导致的额外开销。

    展开全文
  • 为什么用多线程或多进程? 程序的大部分耗时在等待IO上,瓶颈不在CPU上时,可以提高CPU利用率 需要集中快速处理大量数据,并且不受先后顺序影响 评论区还可补充ing 线程和线程 线程的实现可以分为两类: 用户级...

    码字不易,转载请附原链,搬砖繁忙回复不及时见谅,技术交流请加QQ群:909211071

    前言

    为什么用多线程或多进程?

    1. 程序的大部分耗时在等待IO上,瓶颈不在CPU上时,可以提高CPU利用率
    2. 需要集中快速处理大量数据,并且不受先后顺序影响
    3. 评论区还可补充ing

    线程和线程

    线程的实现可以分为两类:

    • 用户级线程:不需要内核支持而在用户程序中实现的线程,其不依赖于操作系统核心,在语言层面利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。不需要用户态/内核态切换,速度快,操作系统内核不知道多线程的存在,因此一个线 程阻塞将使得整个进程(包括它的所有线程)阻塞。由于这里的处理器时间片分配是以进程为基本单位,所以每个线程执行的时间相对减少
    • 内核线线程:又称为内核支持的线程或轻量级进程,所以需要切换到内核态。

    进程切换都需要内核态转换

    为什么进程切换比线程切换开销大?

           逻辑地址:操作系统在页表中记录了逻辑地址到物理内存地址的映射关系,有了页表就可以将逻辑地址转换为物理内存地址了。每个进程都有自己的逻辑地址,进程内的所有线程共享进程的逻辑地址。

           进程切换与线程切换的最主要区别:进程切换涉及到虚拟地址空间的切换而线程切换则不会。因为每个进程都有自己的虚拟地址空间,而线程是共享所在进程的虚拟地址空间的,因此同一个进程中的线程进行线程切换时不涉及虚拟地址空间的转换。把虚拟地址转换为物理地址需要查找页表,页表查找是一个很慢的过程,因此通常使用TLB(Translation Lookaside Buffer)来缓存页地址,用来加速页表查找。当进程切换后页表也要进行切换,页表切换后TLB就失效了,那么虚拟地址转换为物理地址就会变慢,表现出来的就是程序运行会变慢,而线程切换则不会导致TLB失效,因为线程线程无需切换地址空间,因此我们通常说线程切换要比较进程切换块,原因就在这里。

    展开全文
  • 多线程的线程开销

    2021-03-06 05:27:49
    多线程中两个必要的开销:线程的创建、上下文切换创建线程:创建线程使用是直接向系统申请资源的,对操作系统来说,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度,同时在线程切换的时候还要执行内存...
  • 这样的问题确实不好回答,除非你真正理解了进程和线程的原理,否则很容易掉入面试大坑。本讲,我将带你一起探究问题背后的原理,围绕面试题展开理论与实践知识的学习。通过本讲的学习,希望你可以真正理解进程和线程...
  • 进程、线程上下文切换开销

    千次阅读 2020-09-10 11:21:07
    进程、线程上下文切换开销 虚拟内存与地址空间映射关系 虚拟内存是操作系统为每个进程提供的一种抽象,每个进程都有属于自己的、私有的、地址连续的虚拟内存,当然我们知道最终进程的数据及代码必然要放到物理...
  • 多线程中两个必要的开销:线程的创建、上下文切换 上下文切换: 概念: 当前任务执行一个时间片后会切换到下一个任务。在切换之前,上一个任务的状态会被保存下来,下次切换回这个任务时,可以再加载这个任务的...
  • 为什么切换线程切换进程开销

    千次阅读 2019-03-29 08:16:00
     关于进程的定义有很,一个经典的定义是一个执行中程序的实例,进程是程序的动态表现。 一个程序进行起来后,会使用很资源,比如使用寄存器,内存,文件等。每当切换进程时,必须要考虑保存当前进程的状态。...
  • 进程切换开销大的原因

    千次阅读 2021-02-28 21:24:28
    进程的切换时需要进行保护现场 进程开销线程大的原因 进程切换的方式 进程的切换方式
  • 而且由于线程之间切换开销导致多线程往往比实际的单线程还要慢,所以在 python 中计算密集型任务通常使用多进程,因为各个进程有各自独立的 GIL,互不干扰。 而在 IO 密集型任务中,CPU 时常处于等待状态,操作...
  • 什么是进程 一个程序一般对应一个进程,每个程序在执行过程中肯定要获得一些资源,...上面把进程比喻成一个工厂,那么线程就是工厂里的一条流水线,线程就是个流水线,这些流水线相互之间独立,拥有自己加工的数
  • 线程切换怎么样一个流程?

    千次阅读 2021-07-07 00:17:03
    点击上方“朱小厮的博客”,选择“设为星标”后台回复"书",获取后台回复“k8s”,可领取k8s资料进程切换分两步:1.切换页目录以使用新的地址空间2.切换内核栈和硬件上下文...
  • 线程调度为什么比进程调度更少开销? 最仅的面试遭遇了这样一个问题:进程为什么重,线程为什么轻?我回答了一条:进程切换开销要远大于线程。面试官让我详细分析:他们各...
  • 关于资源,Java线程线程栈所占用的内存是在Java堆外的,所以是不受java程序控制的,只受系统资源限制,默认一个线程线程栈大小是1M(当让这个可以通过设置-Xss属性设置,但是要注意栈溢出问题),但是,如果每个...
  • 自发和非自发的调用操作,都会导致上下文切换,会导致系统资源开销。 2、在 JDK 的 java.lang.Thread.State 源码中定义了6个状态,在某一时刻,一个线程只能处于一种状态:New、Runnable、Blocked、Waiting、Timed ...
  • 线程切换比进程快

    千次阅读 2020-11-30 17:53:57
    我们都知道线程切换开销比进程切换的开销小,那么小在什么地方?切换的过程是怎样的? 无论是在多核还是单核系统中,一个CPU看上去都像是在并发的执行个进程,这是通过处理器在进程间切换来实现的。 操作系统...
  • 面试 | 多线程中的上下文切换

    千次阅读 多人点赞 2020-11-13 08:33:22
    点击关注"故里学Java"右上角"设为星标"好文章不错过双十一前的一个月,所有的电商相关的系统都在进行压测,不断的优化系统,我们的电商ERP系统也进行了...
  • 60年代,在OS中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程出现了很弊端,一是由于进程是资源拥有者,创建、撤消与切换存在较大的时空开销,因此需要引入轻型进程;二是由于对称处理...
  • 多线程带来的问题 为什么需要多线程 其实说白了,时代变了,现在的机器都是多核的了,为了榨干机器最后的性能我们引入单线程。 为了充分利用CPU资源,为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不...
  • 多线程的代价及上下文切换

    万次阅读 2016-08-04 19:41:27
    多线程的代价  使用多线程往往可以获得更大的吞吐率和更短的响应时间,但是,使用多线程不一定就比单线程程序跑的快,这取决于我们程序设计者的能力以及应用场景的不同。不要为了多线程多线程,而应考虑...
  • 线程开销

    千次阅读 2015-08-10 13:19:38
    线程是非常强悍的一个概念,因为它们使...但是,和一切虚拟化机制一样,线程会产生空间(内存耗用)和时间(运行时的执行性能)上的开销。 下面更详细地探讨这种开销。每个线程中,都有以下要素:l 线程内核对象(thre
  • 架构师:『试试使用多线程优化』 第二天 头发很多的程序员:『师父,我已经使用了多线程,为什么接口还变慢了?』 架构师:『去给我买杯咖啡,我写篇文章告诉你』 ……吭哧吭哧买咖啡去了 在实际工作中,错误...
  • 【Python 爬虫】多线程爬取

    千次阅读 2022-03-20 10:44:40
    文章目录前言一、多进程库(multiprocessing)二、多线程爬虫三、案例实操四、案例解析1、获取网页内容2、获取每一章链接3、获取每一章的正文并返回章节名和正文4、将每一章保存到本地5、多线程爬取文章 前言 简单...
  • 线程的上下文切换 ...所以在切换时需要保存线程切换前的运行状态,以便下一次,可以接着切换之前的状态继续执行后续的任务 2.切出切入的过程中,操作系统需要保存和恢复相应的进度信息,这个进度信息就是上下文
  • Java多线程学习(吐血超详细总结)

    万次阅读 多人点赞 2015-03-14 13:13:17
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,673
精华内容 49,869
关键字:

多线程切换开销

友情链接: 1001.zip