精华内容
下载资源
问答
  • 本文实例讲述了Python实现可设置持续运行时间、线程数及时间间隔的多线程异步post请求功能。分享给大家供大家参考,具体如下: #coding=utf8 ''' random.randint(a, b):用于生成一个指定范围内的整数。 其中参数a是...
  • 但是线程池的线程数量上线是多少呢,有如何合理估算线程数量保证性能呢,如果脑子里是问号,请往下看。 总得来说,线程池的大小(上线和理想数量)由程序所处的系统和要执行的任务资源性质和程序要执行的任务类型来...

    提到线程池的数量,也许我们能想到通过java相关的api,比如ThreadPollExecutor的构造去设置。但是线程池的线程数量上线是多少呢,有如何合理估算线程数量保证性能呢,如果脑子里是问号,请往下看。

    总得来说,线程池的大小(上线和理想数量)由程序所处的系统和要执行的任务资源性质程序要执行的任务类型来决定。在学习中,我们用固定的数字去测试,只能说是小demo。而在我们程序代码中往往不会去固定线程池的大小。因为根据上面提到的两个因素,我们知道线程池大小往往应该是动态的,所以应该通过动态的方式去设置线程池大小。下面我们就两面两个因素去阐述。

    程序所处的系统和要执行的任务资源性质

    我们可以通过java.lang.Runtime去获取jvm所在系统的cpu数量,还有jvm的可用内存,闲置内存和试图可获取的内存,分别是

    Runtime runtime = Runtime.getRuntime();
    int i = runtime.availableProcessors();
    runtime.freeMemory()
    runtime.maxMemory()
    runtime.totalMemory()
    

    当然内存的大小不是线程池大小唯一的决定因素,其他的还有比如说文件句柄,套接字句柄和数据库连接等等。它们遵循这短板效应。原则上,我们用这些资源的可用总量去除以每个任务对资源的需求量就得到了线程池大小的上线

    程序要执行的任务类型

    任务类型分为计算密集型和IO密集型。先抛出一个公式

    合理线程数量=CPU数量*CPU使用率*(1+等待事件/计算时间)
    

    注意:如果是计算密集型,换句话说,线程绝大部分消耗都在CPU计算处理上,那么启动再多的线程也无济于事,所以线程数量=cpu合数比较合适。
    如果是IO密集型,线程很到部分消耗在等待上,所以可以启动更多的线程,但是线程数量不能超过线程池的上限,也就是上面我们已经阐述过的计算方式。

    展开全文
  • 线程、进程、多线程、多进程 和 多任务 小结

    千次阅读 多人点赞 2019-04-20 11:59:56
    4 多线程 5 线程与进程的关系 6 线程和进程的区别 7 进程的优缺点 7.1 进程的优点 7.2 进程的缺点 8 线程的优缺点 8.1 线程的优点 8.2 线程的缺点 9 多线程的优缺点 9.1 多线程的优点 9.2 多线程的缺点 ...

    目录

    1 进程

    2 线程

    3 多进程

    4 多线程

    5 线程与进程的关系

    6 线程和进程的区别

    7 进程的优缺点

    7.1 进程的优点

    7.2 进程的缺点

    8 线程的优缺点

    8.1 线程的优点

    8.2 线程的缺点

    9 多线程的优缺点

    9.1 多线程的优点

    9.2 多线程的缺点

    10多进程的优缺点

    10.1 多进程的优点

    10.2 多进程的缺点

    8 多任务(多进程)

    参考资料


    最近经常看到 多进程,多线程和多任务等名词,很容易混。网上查了很多资料,内容很多。作为Linux初学者,还是想从最基础的开始了解,找通俗的例子了解,由浅入深。我把网上查阅的资料整理的一下,一次性全部摸透,还是有点难度的。写个博客,记录一下,以便后期查阅复习。

    首先,从定义开始,先看一下教科书上 进程线程定义:

    进程:资源分配的最小单位。

    线程:程序执行的最小单位。

    心中默念,啥啥啥,写的这是啥。于是乎 我就想到王宝强一脸懵逼的表情。

     

    1 进程

    进程是程序执行时的一个实例,即它是程序已经执行到课中程度的数据结构的汇集。从内核的观点看,进程的目的就是担当分配系统资源(CPU时间、内存等)的基本单位。

    举例说明进程

    想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱,厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中,做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(CPU),而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来,说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态),然后拿出一本急救手册,按照其中的指示处理蛰伤。这里,我们看到处理机制是从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治),每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后,这位计算机科学家又回来做蛋糕,从他离开时的那一步继续做下去。

     

    2 线程

    线程是CPU调度的最小单位(程序执行流的最小单元),它被包含在进程之中,是进程中的实际运作单元。一条线程是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

    一个标准的线程有线程ID、当前指令指针(PC),寄存器集合和堆栈组成。另外,线程是进程中的一个实体,是被系统独立调度和分派的基本单元,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程,同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现处间断性。

    线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件,逻辑上可以运行,在等待处理机;运行状态是指线程占有处理机正在运行;阻塞状态是指线程在等待一个事件(如某个信号量),逻辑上不可执行。每一个程序都至少有一个线程,若程序只有一个线程,那就是程序本身。

     

    举例说明线程

    假设,一个文本程序,需要接受键盘输入,将内容显示在屏幕上,还需要保存信息到硬盘中。若只有一个进程,势必造成同一时间只能干一样事的尴尬(当保存时,就不能通过键盘输入内容)。若有多个进程,每个进程负责一个任务,进程A负责接收键盘输入的任务,进程B负责将内容显示在屏幕上的任务,进程C负责保存内容到硬盘中的任务。这里进程A,B,C间的协作涉及到了进程通信问题,而且有共同都需要拥有的东西——-文本内容,不停的切换造成性能上的损失。若有一种机制,可以使任务A,B,C共享资源,这样上下文切换所需要保存和恢复的内容就少了,同时又可以减少通信所带来的性能损耗,那就好了。这种机制就是线程

    总的来说进程有独立的地址空间,线程没有单独的地址空间(同一进程内的线程共享进程的地址空间)。

     

     

    3 多进程

    进程是程序在计算机上的一次执行活动。当你运行一个程序,你就启动了一个进程。显然,程序是死的(静态的),进程是活的(动态的)。进程可以分为系统进程用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程,它们就是处于运行状态下的操作系统本身;所有由用户启动的进程都是用户进程。进程是操作系统进行资源分配的单位。 进程又被细化为线程,也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里,同一个计算机系统中如果允许两个或两个以上的进程处于运行状态,这便是多任务。现代的操作系统几乎都是多任务操作系统,能够同时管理多个进程的运行。 多任务带来的好处是明显的,比如你可以边听网易云音乐,一边上网,与此同时甚至可以将下载的文档打印出来,而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题,俗话说,一心不能二用,这对计算机也一样,原则上一个CPU只能分配给一个进程,以便运行这个进程。我们通常使用的计算机中只有一个CPU,也就是说只有一颗心,要让它一心多用,同时运行多个进程,就必须使用并发技术。实现并发技术相当复杂,最容易理解的是“时间片轮转进程调度算法”,它的思想简单介绍如下:在操作系统的管理下,所有正在运行的进程轮流使用CPU,每个进程允许占用CPU的时间非常短(比如10毫秒),这样用户根本感觉不出来 CPU是在轮流为多个进程服务,就好像所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。 如果一台计算机有多个CPU,情况就不同了,如果进程数小于CPU数,则不同的进程可以分配给不同的CPU来运行,这样,多个进程就是真正同时运行的,这便是并行

    并行处理(Parallel Processing)是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理(concurrency Processing):指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机(CPU)上运行,但任一个时刻点上只有一个程序在处理机(CPU)上运行

    并发的关键是你有处理多个任务的能力,不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说,并行是并发的子集。

     

     

    4 多线程

    线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元,是系统独立调度和分派CPU的基本单元。在单一程序中同时运行多个想成完成不同的工作,称为多线程

    多线程是为了使得多个线程并行的工作以完成多项任务,以提高系统的效率。线程是在同一时间需要完成多项任务的时候被实现的。

    打个比方:

    多进程是立体交通系统(近似于立交桥),虽然造价高,上坡下坡多耗点油,但是不堵车。

    多线程是平面交通系统,造价低,但红绿灯太多,老堵车。

     

     

    5 线程与进程的关系

    (1)一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程;

    (2)资源分配给进程,同一进程内的所有线程共享该进程的所有资源;

    (3)线程在执行过程中需要协作同步。不同进程中的线程之间要利用消息通信的方法实现同步;

    (4)处理机分配给线程,即真正在处理机上运行的是线程;

    (5)线程是进程的一个执行单元,也是进程内的可调用实体。

     

     

    6 线程和进程的区别

    (1)线程共享内存空间;进程的内存是独立的;

    (2)同一个进程的线程之间可以直接交流;两个进程想通信,必须通过一个中间代理来实现;

    (3)创建新进程很简单;创建新进程需要对其父进程进行一个克隆;

    (4)一个线程可以控制和操作同一进程里的其他线程;但是进程只能操作子进程;

    (5)改变注线程(如优先权),可能会影响其他线程;改变父进程,不影响子进程。

    (6)调度:线程作为分配和调度的基本单位,进程作为拥有资源的基本单位

    (7)并发性:不进进程之间可以并发执行,同一进程内的线程也可以并发执行

    (8)拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但是可以访问隶属于进程的系统资源

    (9)系统开销:在创建和撤销进程的时候,系统都要分配和回收资源,导致系统的明显大于创建和撤销线程时的开销。但进程有独立的地址空间,进程崩溃后,在保护模式的下不会对其他进程造成影响,而线程只是进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有独立的地址空间,一个线程死后就等于整个进程死掉,所以多进程程序要比多线程程序健壮,但是在进程切换的时候消耗的资源较大,效率差。

    根本区别就一点:用多进程每个进程有自己的地址空间(address space),线程则共享地址空间。

    总结:多线程执行效率高;  多进程耗资源,安全。

     

     

    7 进程的优缺点

    7.1 进程的优点

    1)顺序程序的特点:具有封闭性和可再现性;

    2)程序的并发执行和资源共享。多道程序设计出现后,实现了程序的并发执行和资源共享,提高了系统的效率和系统的资源利用率。

     

    7.2 进程的缺点

    操作系统调度切换多个线程要比切换调度进程在速度上快的多。而且进程间内存无法共享,通讯也比较麻烦。线程之间由于共享进程内存空间,所以交换数据非常方便;在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。  

     

     

    8 线程的优缺点

    8.1 线程的优点

    1)它是一种非常"节俭"的多任务操作方式。在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码 段、堆栈段和数据段,这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程 所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。当然,在具体的系统上,这个数据可能 会有较大的区别;

    2)线程间方便的通信机制,由于同一进程下的线程之间共享数据空间,所以一个线程的数据可以直接为其它线程所用,这不仅快捷,而且方便;

    3)使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时,不同的线程运行于不同的CPU上;

    4)改善程序结构。一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或半独立的运行部分,这样的程序会利于理解和修改。

     

    8.2 线程的缺点

    1)调度时, 要保存线程状态,频繁调度,需要占用大量的机时;

    2)程序设计上容易出错(线程同步问题)。

     

     

    9 多线程的优缺点

    9.1 多线程的优点

    1)无需跨进程边界; 程序逻辑和控制方式简单;

    2)所有线程可以直接共享内存和变量等;

    3)线程方式消耗的总资源比进程方式好。

     

    9.2 多线程的缺点

    1)每个线程与主程序共用地址空间,受限于2GB地址空间;

    2)线程之间的同步和加锁控制比较麻烦; 一个线程的崩溃可能影响到整个程序的稳定性;

    3)到达一定的线程数程度后,即使再增加CPU也无法提高性能,例如Windows Server 2003,大约是1500个左右的线程数就快到极限了(线程堆栈设定为1M),如果设定线程堆栈为2M,还达不到1500个线程总数;

    4)线程能够提高的总性能有限,而且线程多了之后,线程本身的调度也是一个麻烦事儿,需要消耗较多的CPU 。

     

    10多进程的优缺点

    10.1 多进程的优点

    1)每个进程互相独立,不影响主程序的稳定性,子进程崩溃没关系;

    2)通过增加CPU,就可以容易扩充性能;

    3)可以尽量减少线程加锁/解锁的影响,极大提高性能,就算是线程运行的模块算法效率低也没关系;

    4)每个子进程都有2GB地址空间和相关资源,总体能够达到的性能上限非常大。

     

    10.2 多进程的缺点

    1)逻辑控制复杂,需要和主程序交互;

    2)需要跨进程边界,如果有大数据量传送,就不太好,适合小数据量传送、密集运算 多进程调度开销比较大。

     

    总结:最好是多进程和多线程结合,即根据实际的需要,每个CPU开启一个子进程,这个子进程开启多线程可以为若干同类型的数据进行处理。当然你也可以利用多线程+CPU+轮询方式来解决问题……方法和手段是多样的,关键是自己看起来实现方便有能够满足要求,代价也合适。

     

    按照多个不同的维度(类别),来看看多线程和多进程的对比(注:因为是感性的比较,因此都是相对的,不是说一个好得不得了,另外一个差的无法忍受)。

        对比类别

                                        多进程

                                     多线程

         总结

    数据共享、同步

    数据共享复杂,需要用IPC;数据是分开的,同步简单

    因为共享进程数据,数据共享简单,但也是因为这个原因导致同步复杂

     各有优势

        内存、CPU

    占用内存多,切换复杂,CPU利用率低

    占用内存少,切换简单,CPU利用率高

     线程占优

     创建销毁、切换

    创建销毁、切换复杂,速度慢

    创建销毁、切换简单,速度很快

     线程占优

        编程、调试

    编程简单,调试简单

    编程复杂,调试复杂

     进程占优

           可靠性

    进程间不会互相影响

    一个线程挂掉将导致整个进程挂掉

     进程占优

           分布式

    适应于多核、多机分布式;如果一台机器不够,扩展到多台机器比较简单

    适应于多核分布式

     进程占优

    其实没有绝对的好与坏,只有哪个更加合适的问题。我们来看实际应用中究竟如何判断更加合适。

    1)需要频繁创建销毁的优先用线程

    这种原则最常见的应用就是Web服务器了,来一个连接建立一个线程,断了就销毁线程,要是用进程,创建和销毁的代价是很难承受的

     

    2)需要进行大量计算的优先使用线程

    所谓大量计算,当然就是要耗费很多CPU,切换频繁了,这种情况下线程是最合适的。这种原则最常见的是图像处理、算法处理。

     

    3)强相关的处理用线程,弱相关的处理用进程

    什么叫强相关、弱相关?理论上很难定义,给个简单的例子就明白了。

    一般的Server需要完成如下任务:消息收发、消息处理。“消息收发”和“消息处理”就是弱相关的任务,而“消息处理”里面可能又分为“消息解码”、“业务处理”,这两个任务相对来说相关性就要强多了。因此“消息收发”和“消息处理”可以分进程设计,“消息解码”、“业务处理”可以分线程设计。当然这种划分方式不是一成不变的,也可以根据实际情况进行调整。

     

    4)可能要扩展到多机分布的用进程,多核分布的用线程

     

    5)都满足需求的情况下,用你最熟悉、最拿手的方式

    至于“数据共享、同步”、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍,我只能说:没有明确的选择方法。但我可以告诉你一个选择原则:如果多进程和多线程都能够满足要求,那么选择你最熟悉、最拿手的那个。需要提醒的是:虽然我给了这么多的选择原则,但实际应用中基本上都是“进程+线程”的结合方式,千万不要真的陷入一种非此即彼的误区。

     

    8 多任务(多进程)

    现代操作系统比如Mac OS X,UNIX,Linux,Windows等,都是支持“多任务”的操作系统。

    什么叫“多任务”呢?简单地说,就是操作系统可以同时运行多个任务。打个比方,你一边在用浏览器上网,一边在听MP3,一边在用Word写论文,这就是多任务,至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着,只是桌面上没有显示而已。

    现在,多核CPU已经非常普及了,但是,即使过去的单核CPU,也可以执行多任务。由于CPU执行代码都是顺序执行的,那么,单核CPU是怎么执行多任务的呢

    其实操作系统轮流让各个任务交替执行,任务1执行0.01秒,切换到任务2,任务2执行0.01秒,再切换到任务3,执行0.01秒……这样反复执行下去。表面上看,每个任务都是交替执行的,但是,由于CPU的执行速度实在是太快了,我们感觉就像所有任务都在同时执行一样。

    真正的并行执行多任务只能在多核CPU上实现,但是,由于任务数量远远多于CPU的核心数量,所以,操作系统也会自动把很多任务轮流调度到每个核心上执行。

    对于操作系统来说,一个任务就是一个进程(Process),比如打开一个浏览器就是启动一个浏览器进程,打开一个记事本就启动了一个记事本进程,打开两个记事本就启动了两个记事本进程,打开一个Word就启动了一个Word进程。

    有些进程还不止同时干一件事,比如Word,它可以同时进行打字、拼写检查、打印等事情。在一个进程内部,要同时干多件事,就需要同时运行多个“子任务”,我们把进程内的这些 “子任务” 称为线程(Thread)。

    由于每个进程至少要干一件事,所以,一个进程至少有一个线程。当然,像Word这种复杂的进程可以有多个线程,多个线程可以同时执行,多线程的执行方式和多进程是一样的,也是由操作系统在多个线程之间快速切换,让每个线程都短暂地交替运行,看起来就像同时执行一样。当然,真正地同时执行多线程需要多核CPU才可能实现。

     

     

    参考资料

    [1] https://www.cnblogs.com/pingqiang/p/8007549.html#多进程多线程

    [2] https://www.cnblogs.com/ww36315610/p/3881533.html?tdsourcetag=s_pctim_aiomsg

    [3] http://www.cnblogs.com/Yogurshine/p/3640206.html

    [4] https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0013868322563729e03f6905ea94f0195528e3647887415000?tdsourcetag=s_pctim_aiomsg

    [5] https://www.cnblogs.com/yuanchenqi/articles/6755717.html#_label3?tdsourcetag=s_pctim_aiomsg

    [6] https://www.cnblogs.com/zhanht/p/5401685.html?tdsourcetag=s_pctim_aiomsg

    [7] https://www.kafan.cn/edu/85866456.html

     

    展开全文
  • 其中参数a是下限,参数b是上限,生成的随机数n: a random.choice(sequence):从序列中获取一个随机元素 参数sequence表示一个有序类型(列表,元组,字符串) ''' import httplib,json import time impo
    #coding=utf8
    '''
    random.randint(a, b):用于生成一个指定范围内的整数。
    其中参数a是下限,参数b是上限,生成的随机数n: a <= n <= b
    
    random.choice(sequence):从序列中获取一个随机元素
    参数sequence表示一个有序类型(列表,元组,字符串)
    
    '''
    import httplib,json
    import time
    import threading
    from random import randint,choice 
    
    #创建请求函数
    def postRequest(threadNum):
        
        postJson={                     
                    }
        #定义需要进行发送的数据
        postData=json.dumps(postJson)
    
        #定义一些文件头
        headerdata = {
          
            "content-type":"application/json",
             }
        
        #接口
        requrl ="/v1/query"
        
        #请求服务,例如:www.baidu.com
        hostServer=""
        #连接服务器       
        conn = httplib.HTTPConnection(hostServer)
        #发送请求       
        conn.request(method="POST",url=requrl,body=postData,headers=headerdata)
        
        #获取请求响应       
        response=conn.getresponse()
        #打印请求状态
        if response.status in range(200,300):
            print u"线程"+str(threadNum)+u"状态码:"+str(response.status)       
        conn.close()   
           
    
    def run(threadNum,internTime,duration):   
        #创建数组存放线程    
        threads=[] 
        try:
            #创建线程
            for i in range(1,threadNum):
                #针对函数创建线程  
                t=threading.Thread(target=postRequest,args=(i,))
                #把创建的线程加入线程组     
                threads.append(t)  
        except Exception,e:
            print e
            
        try: 
            #启动线程  
            for thread in threads: 
                    thread.setDaemon(True)
                    thread.start()
                    time.sleep(internTime) 
                            
            #等待所有线程结束
            for thread in  threads: 
                    thread.join(duration)                                          
        except Exception,e:
                print e
    
    if __name__ == '__main__':
        startime=time.strftime("%Y%m%d%H%M%S")
    
        now=time.strftime("%Y%m%d%H%M%S")
        duratiion=raw_input(u"输入持续运行时间:")
        while (startime+str(duratiion))!=now:  
            run(10,1,int(duration))
            now=time.strftime("%Y%m%d%H%M%S") 
           
       
                
       
    
    
    
    

    运行结果截图:


    展开全文
  • 多进程和多线程的主要区别是:线程是进程的子集(部分),一个进程可能由多个线程组成。多进程的数据是分开的、共享复杂,需要用IPC;但同步简单。多线程共享进程数据,共享简单;但同步复杂。  多进程,Windows...

     

    多进程和多线程的主要区别是:线程是进程的子集(部分),一个进程可能由多个线程组成。多进程的数据是分开的、共享复杂,需要用IPC;但同步简单。多线程共享进程数据,共享简单;但同步复杂。

      多进程,Windows 应用程序中消息有两种送出途径;直接和排队。Windows或某些运行的应用程序可直接发布消息给窗口过程,或者,消息可送到消息列象连续不断轮询消息队列的OS中当前执行的每个进程都 事件驱动程序不是由事件的顺序来控制,而是由事件的发生来控,而事件的发生是随机的、不确定的,这就允许程序的用户用各种合理的顺序来安排程序的流程。

      多线程(英语:multithreading),是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程,进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理(Chip-level multithreading)或同时多线程(Simultaneous multithreading)处理器。[1] 在一个程序中,这些独立运行的程序片段叫作“线程”(Thread),利用它编程的概念就叫作“多线程处理(Multithreading)”。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程(台湾译作“执行绪”),进而提升整体处理性能。

    一、多进程和多线程的区别是什么?

      在Linux下编程多用多进程编程少用多线程编程。

      IBM有个家伙做了个测试,发现切换线程context的时候,windows比linux快一倍多。进出最快的锁(windows2k的 critical section和linux的pthread_mutex),windows比linux的要快五倍左右。当然这并不是说linux不好,而且在经过实际编程之后,综合来看我觉得linux更适合做high performance server,不过在多线程这个具体的领域内,linux还是稍逊windows一点。这应该是情有可原的,毕竟unix家族都是从多进程过来的,而 windows从头就是多线程的。

      如果是UNIX/linux环境,采用多线程没必要。

      多线程比多进程性能高?误导!

      应该说,多线程比多进程成本低,但性能更低。

      在UNIX环境,多进程调度开销比多线程调度开销,没有显著区别,就是说,UNIX进程调度效率是很高的。内存消耗方面,二者只差全局数据区,现在内存都很便宜,服务器内存动辄若干G,根本不是问题。

      多进程是立体交通系统,虽然造价高,上坡下坡多耗点油,但是不堵车。

      多线程是平面交通系统,造价低,但红绿灯太多,老堵车。

      我们现在都开跑车,油(主频)有的是,不怕上坡下坡,就怕堵车。

      高性能交易服务器中间件,如TUXEDO,都是主张多进程的。实际测试表明,TUXEDO性能和并发效率是非常高的。TUXEDO是贝尔实验室的,与UNIX同宗,应该是对UNIX理解最为深刻的,他们的意见应该具有很大的参考意义。

      二、多进程和多线程的优缺点分析:

      多进程:

      多进程优点:

      1、每个进程互相独立,不影响主程序的稳定性,子进程崩溃没关系;

      2、通过增加CPU,就可以容易扩充性能;

      3、可以尽量减少线程加锁/解锁的影响,极大提高性能,就算是线程运行的模块算法效率低也没关系;

      4、每个子进程都有2GB地址空间和相关资源,总体能够达到的性能上限非常大。

      多进程缺点:

      1、逻辑控制复杂,需要和主程序交互;

      2、需要跨进程边界,如果有大数据量传送,就不太好,适合小数据量传送、密集运算 多进程调度开销比较大;

      3、最好是多进程和多线程结合,即根据实际的需要,每个CPU开启一个子进程,这个子进程开启多线程可以为若干同类型的数据进行处理。当然你也可以利用多线程+多CPU+轮询方式来解决问题……

      4、方法和手段是多样的,关键是自己看起来实现方便有能够满足要求,代价也合适。

      多线程:

      多线程的优点:

      1、无需跨进程边界;

      2、程序逻辑和控制方式简单;

      3、所有线程可以直接共享内存和变量等;

      4、线程方式消耗的总资源比进程方式好。

      多线程缺点:

      1、每个线程与主程序共用地址空间,受限于2GB地址空间;

      2、线程之间的同步和加锁控制比较麻烦;

      3、一个线程的崩溃可能影响到整个程序的稳定性;

      4、到达一定的线程数程度后,即使再增加CPU也无法提高性能,例如Windows Server 2003,大约是1500个左右的线程数就快到极限了(线程堆栈设定为1M),如果设定线程堆栈为2M,还达不到1500个线程总数;

      5、线程能够提高的总性能有限,而且线程多了之后,线程本身的调度也是一个麻烦事儿,需要消耗较多的CPU。

    参考:

    多进程和多线程的区别是什么​? 

    展开全文
  • 多线程特别重要,虽然内容偏多,但是需要熟练掌握。面试也会在此章节有考验的!请大家耐心学习! 目录 一、什么是线程 二、线程的组成(创建线程方式) 三、线程的状态(方法实例详解) 四、线程安全(实例详解)...
  • Java多线程编程 深入详解

    千次阅读 多人点赞 2018-01-17 21:59:54
    《Java多线程编程 深入详解》读书笔记 第一章 多进程多线程概述 线程概述 进程(PROCESS):CPU的执行路径 多进程:系统中同时运行多个程序 线程(THREAD):运行在进程当中的运行单元 多线程...
  • POSIX 多线程程序设计

    千次阅读 2012-12-24 11:58:29
    POSIX 多线程程序设计    目录表  摘要 译者序Pthreads 概述  什么是线程? 什么是Pthreads? 为什么使用Pthreads? 使用线程设计程序 Pthreads API编译多线程程序 线程管理 ...
  • 多进程 VS 多线程

    千次阅读 2015-12-12 22:05:00
    在Linux下编程多用多进程编程少用多线程编程。  IBM有个家伙做了个测试,发现切换线程context的时候,windows比linux快一倍多。进出最快的锁(windows2k的 critical section和linux的pthread_mutex),windows比...
  • 异步执行函数线程Dome 调用MSVC CRT的函数_beginthread()或_beginthreadex()来创建线程。 _beginthread 参数和返回值 unsigned long _beginthread( void(_cdecl *start_address)(void *), //声明为void (*start_...
  • C#多线程编程

    千次阅读 2011-12-07 09:52:08
    在.NET多线程编程这个系列我们讲一起来探讨多线程编程的各个方面。首先我将在本篇文章的开始向大家介绍多线程的有关概念以及多线程编程的基础知识;在接下来的文章中,我将逐一讲述。NET平台上多线程编程的知识,诸如...
  • Python多线程编程

    千次阅读 2019-02-28 11:46:07
    多线程(multithreaded, MT)编程出现之前,计算机程序的执行是由单个步骤序列组成的,该序列在主机的 CPU 中按照同步顺序执行。无论是任务本身需要按照步骤顺序执行,还是整个程序实际上包含多个子任务,都需要...
  • C语言多任务,多进程,多线程

    千次阅读 2018-04-03 15:44:08
    Linux就是一种支持多任务的操作系统,它支持多进程、多线程等多任务处理和任务之间的多种通信机制。Linux下多任务机制的介绍多任务处理是指用户在同一时间内运行多个应用程序,每个应用程序被称做一个任务。Linux...
  • Python 多线程 multithread

    千次阅读 2015-07-29 12:47:30
    【Python】python 多线程两种实现方式 目前python提供了几种多线程实现方式 thread,threading,multithreading ,其中thread模块比较底层,而threading模块是对thread做了一些包装,可以更加方便的被使用。 2.7...
  • Java多线程并发协同

    千次阅读 2018-08-02 22:51:26
    Java并发相关技术:线程池、线程安全(锁)、多线程并发协同、并发集合类、原子类。 什么是并发协同? 多个线程并发,协同来完成一件事情的过程中,因事情处理的需要,需控制某些线程阻塞,等待另一些线程完成某...
  • Python多线程-手慢无的真相

    千次阅读 多人点赞 2021-02-24 15:44:46
    我们常说的「手慢无」其实类似多线程同时竞争一个共享资源的结果,要保证结果的唯一正确性,而这让我们从线程(Python)慢慢说起…… 文章目录 线程的概念 创建多线程 主线程 阻塞线程 线程方法 线程同步 同步的概念...
  • 多线程(单例模式)

    千次阅读 2019-10-29 08:58:51
    1,多线程,把耗时操作方法另外一个线程单独执行 2,使用消息列对分隔两个操作 多线程: 进程:计算机上可以单独执行的程序。 线程:执行代码的地方。 一个进程至少包含一个线程,这个线程叫做主线程。 代码在...
  • java多线程-Thead线程学习记录笔记

    千次阅读 2020-01-22 11:15:59
    主要介绍多线程的基本概念到后面的基本使用。以及一些稍微的原理猜测。个人笔记,不喜勿喷 目录 目录 一、线程使用 1.1 概念 1.2 线程生命周期 1.3 java中实现的方式 1.3.1继承线程 Thread 1.3.2 实现接口...
  • 多进程与多线程的优缺点

    千次阅读 2015-08-11 13:59:43
    比较多进程与多线程的优缺点
  • 面经整理-多线程

    万次阅读 2017-12-05 16:17:43
    多线程,线程池,并发编程,volatile,synchronized,锁,原子类,代码可重入,有状态和无状态,ThreadLocal
  • python ThreadPoolExecutor 多线程踩坑之旅

    千次阅读 2019-08-10 15:18:58
    最近做了套接口测试系统,后台定时任务会批量去跑测试用例,用的是多线程,以前多线程模块用的是自己封装的包,但因为一些原因近期替换成了python标准库中的ThreadPoolExecutor,于是问题开始了…… 项目用的是:...
  • 多线程(八)线程队列

    千次阅读 2017-03-31 09:13:50
    本文参考以下文章整理而成,希望大家多多指教!共同学习!原文地址如下:Java 并发工具包...Java线程(篇外篇):阻塞队列BlockingQueue引言  在上一篇多线程(七)线程池详解中提到了线程队列,相信大家现在已清楚明白线
  • QT 多线程 线程池 QRunnalbe QThreadPool

    千次阅读 2019-03-19 17:22:22
    QT中线程很早就出现了,多线程的使用目的是为了减轻主线程压力,不至于主线程界面卡顿,提高用户体验。但是线程的创建与销毁需要与系统交互,会产生很大的开销。若需要频繁的创建线程就建议使用线程池,有线程池...
  • Java多线程导论及延申

    千次阅读 2021-03-16 16:52:46
    多线程导论 原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度,既不被中断操作,要不执行完成,要不就不执行。 可见性是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看...
  • 彻头彻尾理解单例模式与多线程

    万次阅读 多人点赞 2017-03-20 16:26:03
    多线程环境下,我们特别介绍了五种方式来在多线程环境下创建线程安全的单例,使用synchronized方法、synchronized块、静态内部类、双重检查和ThreadLocal实现懒汉式单例,并给出实现效率高且线程安全的单例所需要...
  • Python多线程

    千次阅读 2013-04-25 18:22:56
    多线程是程序设计中的一个重要方面,尤其是在服务器Deamon程序方面。无论何种系统,线程调度的开销都比传统的进程要快得多。  Python可以方便地支持多线程。可以快速创建线程、互斥锁、信号量等等元素,支持线程...
  • springboot定时任务开启多线程

    千次阅读 2020-04-07 14:56:27
    在开发过程中避免不了要使用定时任务,例如:定时统计数据,上传数据等等。而springboot的定时任务Scheduled默认是单线程。所以当一个类中需要执行的定时方法过多是,任务就会排队,不...这时候就需要配置多线程了。...
  • Java面试题--多线程

    万次阅读 多人点赞 2019-04-07 12:41:26
    程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。 线程和进程有什么区别? 线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,993
精华内容 27,597
关键字:

多线程的时间上限