线程与进程_线程与进程的区别 - CSDN
精华内容
参与话题
  •  线程进程中执行运算的最小单位,是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可同属一个进程的其它线程共享进程所拥有的全部资源...

    线程和进程有什么区别(简单介绍)

    简单介绍

    一、线程的基本概念

      线程是进程中执行运算的最小单位,是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。

        好处 :(1)易于调度。

                   (2)提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。

                   (3)开销少。创建线程比创建进程要快,所需开销很少。。

                   (4)利于充分发挥多处理器的功能。通过创建多线程进程,每个线程在一个处理器上运行,从而实现应用程序的并发性,使每个处理器都得到充分运行

    二、进程与线程

    进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。(进程是资源分配的最小单位)

    线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。(线程是cpu调度的最小单位)

    线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。

     

    多进程是指操作系统能同时运行多个任务(程序)。

    多线程是指在同一程序中有多个顺序流在执行。

    每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的集合,或者是程序的特殊段,它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程,它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。

    在Java中,一个应用程序可以包含多个线程。每个线程执行特定的任务,并可与其他线程并发执行多线程使系统的空转时间最少,提高CPU利用率、多线程编程环境用方便的模型隐藏CPU在任务间切换的事实在Java程序启动时,一个线程立刻运行,该线程通常称为程序的主线程。

    主线程的重要性体现在两个方面:

    1、它是产生其他子线程的线程。

    2、通常它必须最后完成执行,因为它执行各种关闭动作。

     三、进程与线程的区别:

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

        (2)并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可并发执行

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

        (4)系统开销:在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。

     四、同步和互斥的区别:

    当有多个线程的时候,经常需要去同步这些线程以访问同一个数据或资源。例如,假设有一个程序,其中一个线程用于把文件读到内存,而另一个线程用于统计文件中的字符数。当然,在把整个文件调入内存之前,统计它的计数是没有意义的。但是,由于每个操作都有自己的线程,操作系统会把两个线程当作是互不相干的任务分别执行,这样就可能在没有把整个文件装入内存时统计字数。为解决此问题,你必须使两个线程同步工作。

          所谓同步,是指散步在不同进程之间的若干程序片断,它们的运行必须严格按照规定的某种先后次序来运行,这种先后次序依赖于要完成的特定的任务。如果用对资源的访问来定义的话,同步是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

            所谓互斥,是指散布在不同进程之间的若干程序片断,当某个进程运行其中一个程序片段时,其它进程就不能运行它们之中的任一程序片段,只能等到该进程运行完这个程序片段后才可以运行。如果用对资源的访问来定义的话,互斥某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的。

     五、进程间通信的方式?

    (1)管道(pipe)及有名管道(named pipe):管道可用于具有亲缘关系的父子进程间的通信,有名管道除了具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。

        (2)信号(signal):信号是在软件层次上对中断机制的一种模拟,它是比较复杂的通信方式,用于通知进程有某事件发生,一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。

        (3)消息队列(message queue):消息队列是消息的链接表,它克服了上两种通信方式中信号量有限的缺点,具有写权限得进程可以按照一定得规则向消息队列中添加新信息;对消息队列有读权限得进程则可以从消息队列中读取信息。

        (4)共享内存(shared memory):可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间,不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作,如互斥锁和信号量等。

        (5)信号量(semaphore):主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

        (6)套接字(socket):这是一种更为一般得进程间通信机制,它可用于网络中不同机器之间的进程间通信,应用非常广泛。

     六、进程和线程的关系:

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

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

        (3)处理机分给线程,即真正在处理机上运行的是线程。

        (4)线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体.

     七、多线程的优点

      • 使用线程可以把占据时间长的程序中的任务放到后台去处理
      • 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度
      • 程序的运行速度可能加快
      • 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等,线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
      • 多线程技术在IOS软件开发中也有举足轻重的位置。

    八、多线程的缺点

      • 如果有大量的线程,会影响性能,因为操作系统需要在它们之间切换。
      • 更多的线程需要更多的内存空间。
      • 线程可能会给程序带来更多“bug”,因此要小心使用。
      • 线程的中止需要考虑其对程序运行的影响。
      • 通常块模型数据是在多个线程间共享的,需要防止线程死锁情况的发生。

    总结:

    线程和进程的区别在于,子进程和父进程有不同的代码和数据空间,而多个线程则共享数据空间,每个线程有自己的执行堆栈和程序计数器为其执行上下文.多线程主要是为了节约CPU时间,发挥利用,根据具体情况而定. 线程的运行中需要使用计算机的内存资源和CPU。

    posted @ 2018-08-13 19:23 韦邦杠 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 进程线程的深入理解

    万次阅读 多人点赞 2020-06-22 16:02:10
    进程线程的深入理解精确概括进程线程的区别 既然要谈区别,那么首先需要理解什么是进程线程。 之前,我读到一篇材料,发现有一个很好的类比,可以把它们解释地清晰易懂。 1.计算机的核心是CPU,它承担了所有的...

    进程和线程的深入理解


    下面是抽象类比:

    单CPU:一台单核处理器计算机 = 一个车间;
    多CPU:一台多核处理器计算机 = 一座工厂;

    进程:一个车间 = 一个进程; (即一个运行的程序)
    多进程:一座工厂可以同时运行多个车间;
    CPU和进程单CPU只能同时运行单个进程,多CPU可以同时运行多个进程

    线程:车间内一个工人 = 一个线程;
    进程与线程一个进程可以包括多个线程

    线程间内存共享:车间的空间是工人们共享的,比如许多房间是每个工人都可以进出的。
    一个进程的内存空间是共享的,每个线程都可以使用这些共享内存

    内存安全:可是,每个车间容纳大小不同,有的最多只能容纳一个人。车间人满的时候,其他人就进不去了。
    一个线程使用某些共享内存时,其他线程必须等它结束,才能使用这一块内存。

    互斥锁:一个防止他人进入的简单方法,就是门口加一把锁。先到的人锁上门,后到的人看到上锁,就在门口排队,等锁打开再进去。
    这就叫"互斥锁"–Mutex,防止两个线程同时读写某一块内存区域

    信号量:这时的解决方法,就是在门口挂n把钥匙。进去的人就取一把钥匙,出来时再把钥匙挂回原处。后到的人发现钥匙架空了,就知道必须在门口排队等着了。
    这种做法叫做"信号量"(Semaphore),用来保证多个线程不会互相冲突

    锁和信号量:不难看出,互斥锁是信号量的一种特殊情况(n=1时)。也就是说,完全可以用后者替代前者。但是,因为mutex较为简单,且效率高,所以在必须保证资源独占的情况下,还是采用这种设计。

    操作系统的资源分配与调度逻辑

    • 以多进程形式,允许多个任务同时运行;
    • 以多线程形式,允许单个任务分成不同的部分运行;
    • 提供协调机制,一方面防止进程之间和线程之间产生冲突,另一方面允许进程之间和线程之间共享资源。

    下面是严谨的解释:

    进程

    进程是程序的一次执行过程,是一个动态概念,是程序在执行过程中分配和管理资源的基本单位,每一个进程都有一个自己的地址空间,至少有 5 种基本状态,它们是:初始态,执行态,等待状态,就绪状态,终止状态。

    线程

    线程是CPU调度和分派的基本单位,它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

    进程和线程的关系

    线程是进程的一部分
    一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程

    进程和线程的区别

    理解它们的差别,我从资源使用的角度出发。(所谓的资源就是计算机里的中央处理器,内存,文件,网络等等)

    根本区别:进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位

    开销方面:每个进程都有独立的代码和数据空间(程序上下文),进程之间切换开销大;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小

    所处环境:在操作系统中能同时运行多个进程(程序);而在同一个进程(程序)中有多个线程同时执行(通过CPU调度,在每个时间片中只有一个线程执行)

    内存分配:系统为每个进程分配不同的内存空间;而对线程而言,除了CPU外,系统不会为线程分配内存(线程所使用的资源来自其所属进程的资源),线程组之间只能共享资源

    包含关系:线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程

    展开全文
  • 进程线程的主要区别(总结)

    万次阅读 多人点赞 2018-06-13 10:11:52
    根本区别:进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位在开销方面:每个进程都有独立的代码和数据空间(程序上下文),程序之间的切换会有较大的开销;线程可以看做轻量级的进程,同一类...

    根本区别:进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位

    在开销方面:每个进程都有独立的代码和数据空间(程序上下文),程序之间的切换会有较大的开销;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小。

    所处环境:在操作系统中能同时运行多个进程(程序);而在同一个进程(程序)中有多个线程同时执行(通过CPU调度,在每个时间片中只有一个线程执行)

    内存分配方面:系统在运行的时候会为每个进程分配不同的内存空间;而对线程而言,除了CPU外,系统不会为线程分配内存(线程所使用的资源来自其所属进程的资源),线程组之间只能共享资源。

    包含关系:没有线程的进程可以看做是单线程的,如果一个进程内有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的;线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程。

    展开全文
  • 我们在学习JAVA或者面试过程中,往往会碰到进程线程、线程池的之间的错综关系,下面我结合网上的资料和自己的理解,总结了三者的关系,从以下几个方面说起: 1、进程线程、线程池的概念  进程是一个动态的...

           我们在学习JAVA或者面试过程中,往往会碰到进程、 线程、线程池的之间的错综关系,下面我结合网上的资料和自己的理解,总结了三者的关系,从以下几个方面说起:

    1、进程、线程、线程池的概念

           进程是一个动态的过程,是一个活动的实体。简单来说,一个应用程序的运行就可以被看做是一个进程,而线程,是运行中的实际的任务执行者。可以说,进程中包含了多个可以同时运行的线程。

          线程,程序执行流的最小执行单位,是进程中的实际运作单位。

         线程池:Java中开辟出了一种管理线程的概念,这个概念叫做线程池,从概念以及应用场景中,我们可以看出,线程池的好处,就是可以方便的管理线程,也可以减少内存的消耗,那为什么我们要使用线程池,主要解决如下几个问题:

    1. 创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率
    2. 线程并发数量过多,抢占系统资源,从而导致系统阻塞
    3. 能够容易的管理线程,比如:线程延迟执行、执行策略等

    2、线程的 生命周期

    线程的生命周期,线程的生命周期可以利用以下的图解来更好的理解:

            首先使用new Thread()的方法新建一个线程,在线程创建完成之后,线程就进入了就绪(Runnable)状态,此时创建出来的线程进入抢占CPU资源的状态,当线程抢到了CPU的执行权之后,线程就进入了运行状态(Running),当该线程的任务执行完成之后或者是非常态的调用的stop()方法之后,线程就进入了死亡状态。而我们在图解中可以看出,线程还具有一个则色的过程,这是怎么回事呢?当面对以下几种情况的时候,容易造成线程阻塞,第一种,当线程主动调用了sleep()方法时,线程会进入则阻塞状态,除此之外,当线程中主动调用了阻塞时的IO方法时,这个方法有一个返回参数,当参数返回之前,线程也会进入阻塞状态,还有一种情况,当线程进入正在等待某个通知时,会进入阻塞状态。那么,为什么会有阻塞状态出现呢?我们都知道,CPU的资源是十分宝贵的,所以,当线程正在进行某种不确定时长的任务时,Java就会收回CPU的执行权,从而合理应用CPU的资源。我们根据图可以看出,线程在阻塞过程结束之后,会重新进入就绪状态,重新抢夺CPU资源。这时候,我们可能会产生一个疑问,如何跳出阻塞过程呢?又以上几种可能造成线程阻塞的情况来看,都是存在一个时间限制的,当sleep()方法的睡眠时长过去后,线程就自动跳出了阻塞状态,第二种则是在返回了一个参数之后,在获取到了等待的通知时,就自动跳出了线程的阻塞过程。

    3、单线程和多线程概念

    单线程,顾名思义即是只有一个线程在执行任务,这种情况在我们日常的工作学习中很少遇到,所以我们只是简单做一下了解

    多线程,创建多个线程同时执行任务,这种方式在我们的日常生活中比较常见。但是,在多线程的使用过程中,还有许多需要我们了解的概念。比如,在理解上并行和并发的区别,以及在实际应用的过程中多线程的安全问题,对此,我们需要进行详细的了解。

    并行和并发:在我们看来,都是可以同时执行多种任务,那么,到底他们二者有什么区别呢?

    并发:从宏观方面来说,并发就是同时进行多种时间,实际上,这几种时间,并不是同时进行的,而是交替进行的,而由于CPU的运算速度非常的快,会造成我们的一种错觉,就是在同一时间内进行了多种事情

    并行:则是真正意义上的同时进行多种事情。这种只可以在多核CPU的基础上完成。

           还有就是多线程的安全问题?为什么会造成多线程的安全问题呢?我们可以想象一下,如果多个线程同时执行一个任务,意味着他们共享同一种资源,由于线程CPU的资源不一定可以被谁抢占到,这是,第一条线程先抢占到CPU资源,他刚刚进行了第一次操作,而此时第二条线程抢占到了CPU的资源,共享资源还来不及发生变化,就同时有两个线程使用了同一条资源,会造成数据不一致性,导致线程执行错误发生。

          有造成问题的原因我们可以看出,这个问题主要的矛盾在于,CPU的使用权抢占和资源的共享发生了冲突,解决时,我们只需要让一条线程占用了CPU的资源时,阻止第二条线程同时抢占CPU的执行权,在代码中,我们只需要在方法中使用同步代码块即可。在这里,同步代码块不多进行赘述,详情查看https://blog.csdn.net/gyshun/article/details/81626942去了解。

    4、JAVA中线程池的实现

          在Java中,线程池的概念是Executor这个接口,具体实现为ThreadPoolExecutor类,学习Java中的线程池,就可以直接学习它。对线程池的配置,就是对ThreadPoolExecutor构造函数的参数的配置,既然这些参数这么重要,就来看看构造函数的各个参数吧

    ThreadPoolExecutor提供了四个构造函数

    
    //五个参数的构造函数
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)
    
    //六个参数的构造函数-1
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory)
    
    //六个参数的构造函数-2
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)
    
    //七个参数的构造函数
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    

            其它这四个构造函数,一共牵涉到7个参数类型,下面主要讲解七个参数。

    • int corePoolSize => 该线程池中核心线程数最大值

      核心线程:

      线程池新建线程的时候,如果当前线程总数小于corePoolSize,则新建的是核心线程,如果超过corePoolSize,则新建的是非核心线程

      核心线程默认情况下会一直存活在线程池中,即使这个核心线程啥也不干(闲置状态)。

      如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true,那么核心线程如果不干活(闲置状态)的话,超过一定时间(时长下面参数决定),就会被销毁掉

      很好理解吧,正常情况下你不干活我也养你,因为我总有用到你的时候,但有时候特殊情况(比如我自己都养不起了),那你不干活我就要把你干掉了

    • int maximumPoolSize

      该线程池中线程总数最大值

      线程总数 = 核心线程数 + 非核心线程数。核心线程在上面解释过了,这里说下非核心线程:

      不是核心线程的线程(别激动,把刀放下…),其实在上面解释过了

    • long keepAliveTime

      该线程池中非核心线程闲置超时时长

      一个非核心线程,如果不干活(闲置状态)的时长超过这个参数所设定的时长,就会被销毁掉

      如果设置allowCoreThreadTimeOut = true,则会作用于核心线程

    • TimeUnit unit

      keepAliveTime的单位,TimeUnit是一个枚举类型,其包括:

      1. NANOSECONDS : 1微毫秒 = 1微秒 / 1000
      2. MICROSECONDS : 1微秒 = 1毫秒 / 1000
      3. MILLISECONDS : 1毫秒 = 1秒 /1000
      4. SECONDS : 秒
      5. MINUTES : 分
      6. HOURS : 小时
      7. DAYS : 天
    • BlockingQueue workQueue

      该线程池中的任务队列:维护着等待执行的Runnable对象

      当所有的核心线程都在干活时,新添加的任务会被添加到这个队列中等待处理,如果队列满了,则新建非核心线程执行任务

      常用的workQueue类型:

      1. SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,而不保留它,如果所有线程都在工作怎么办?那就新建一个线程来处理这个任务!所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误,使用这个类型队列的时候,maximumPoolSize一般指定成Integer.MAX_VALUE,即无限大

      2. LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。由于这个队列没有最大值限制,即所有超过核心线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过corePoolSize

      3. ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则发生错误

      4. DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务

    • ThreadFactory threadFactory

      创建线程的方式,这是一个接口,你new他的时候需要实现他的Thread newThread(Runnable r)方法,一般用不上。

      小伙伴应该知道AsyncTask是对线程池的封装吧?那就直接放一个AsyncTask新建线程池的threadFactory参数源码吧:

      new ThreadFactory() {
          private final AtomicInteger mCount = new AtomicInteger(1);
      
          public Thread new Thread(Runnable r) {
              return new Thread(r,"AsyncTask #" + mCount.getAndIncrement());
          }
      }

       

    • RejectedExecutionHandler handler

      这玩意儿就是抛出异常专用的,比如上面提到的两个错误发生了,就会由这个handler抛出异常,你不指定他也有个默认的抛异常能抛出什么花样来?一般情况下根本用不上。

    新建一个线程池的时候,一般只用5个参数的构造函数。

    向ThreadPoolExecutor添加任务

    那说了这么多,你可能有疑惑,我知道new一个ThreadPoolExecutor,大概知道各个参数是干嘛的,可是我new完了,怎么向线程池提交一个要执行的任务啊?

    通过ThreadPoolExecutor.execute(Runnable command)方法即可向线程池内添加一个任务

    ThreadPoolExecutor的策略

    上面介绍参数的时候其实已经说到了ThreadPoolExecutor执行的策略,这里给总结一下,当一个任务被添加进线程池时:

    1. 线程数量未达到corePoolSize,则新建一个线程(核心线程)执行任务
    2. 线程数量达到了corePools,则将任务移入队列等待
    3. 队列已满,新建线程(非核心线程)执行任务
    4. 队列已满,总线程数又达到了maximumPoolSize,就会由上面那位星期天(RejectedExecutionHandler)抛出异常

    5、常见四种线程池

           如果你不想自己写一个线程池,那么你可以从下面看看有没有符合你要求的(一般都够用了),如果有,那么很好你直接用就行了,如果没有,那你就老老实实自己去写一个吧

          Java通过Executors提供了四种线程池,这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的,下面我都会贴出这四种线程池构造函数的源码,各位大佬们一看便知!

    来,走起:

    CachedThreadPool()

    可缓存线程池:

    1. 线程数无限制(没有核心线程,全部是非核心线程)
    2. 有空闲线程则复用空闲线程,若无空闲线程则新建线程
    3. 一定程序减少频繁创建/销毁线程,减少系统开销

    适用场景:适用于耗时少,任务量大的情况

    创建方法:

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

    源码:

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

     

    FixedThreadPool()

    定长线程池:

    1. 有核心线程,核心线程数就是线程的最大数量(没有非核心线程)
    2. 可控制线程最大并发数(同时执行的线程数)
    3. 超出的线程会在队列中等待

    创建方法:

    //nThreads => 最大线程数即maximumPoolSize
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads);
    
    //threadFactory => 创建线程的方法!
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

    源码:

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    2个参数的构造方法源码,不用我贴你也知道他把星期六放在了哪个位置!所以我就不贴了,省下篇幅给我扯皮

    ScheduledThreadPool()

    定长线程池:

    1. 支持定时及周期性任务执行。
    2. 有核心线程,也有非核心线程
    3. 非核心线程数量为无限大

    适用场景:适用于执行周期性任务

    创建方法:

    //nThreads => 最大线程数即maximumPoolSize
    ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

    源码:

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
    //ScheduledThreadPoolExecutor():
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

    SingleThreadExecutor()

    单线程化的线程池:

    1. 有且仅有一个工作线程执行任务
    2. 所有任务按照指定顺序执行,即遵循队列的入队出队规则

    适用场景:适用于有顺序的任务应用场景

    创建方法:

    ExecutorService singleThreadPool = Executors.newSingleThreadPool();

    源码:

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    还有一个Executors.newSingleThreadScheduledExecutor()结合了3和4,就不介绍了,基本不用。

    展开全文
  • 什么是进程?什么是线程进程与线程的区别?

    千次阅读 多人点赞 2018-07-20 10:03:57
    进程与线程的区别? 进程与线程的选择取决条件? 什么是进程?什么是线程? 进程:进程是并发执行程序在执行过程中资源分配和管理的基本单位(资源分配的最小单位)。进程可以理解为一个应用程序的执行过程,应用...
  • 线程与进程的区别

    万次阅读 2018-12-30 17:26:58
    进程线程的区别 进程:是并发执行的程序在执行过程中分配和管理资源的基本单位,是一个动态概念,竞争计算机系统资源的基本单位。 线程:是进程的一个执行单元,是进程内科调度实体。比进程更小的独立运行的基本...
  • 程序,进程线程的区别和联系

    万次阅读 多人点赞 2019-05-31 16:26:13
    进程和程序区别和联系表现在以下方面: 1)程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期...
  • 线程与进程的关系

    千次阅读 2019-10-17 17:57:19
    线程进程1 线程进程2
  • 线程与进程

    千次阅读 2018-03-01 15:51:03
    作者:pansz链接:...单进程线程:一个人在一个桌子上吃菜。2。单进程线程:多个人在同一个桌子上一起吃菜。3。多进程单线程:多个人每个人在自己的桌子上吃菜。多线程的问题是多个人同时吃一道菜的...
  • 进程线程的区别(超详细)

    万次阅读 多人点赞 2019-11-07 15:58:33
    进程线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程,比如...与进程不同的是同类的多个线程共享进程的堆和方法区资源,但每个线程有自己的程序计数器、虚拟...
  • 线程是什么?要理解这个概念,须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式,也就是说一个任务执行一小段时间后强制暂停去执行下一个任务,...
  • C++·线程与进程

    千次阅读 2018-07-27 08:20:31
    一、多线程的好处 1.发挥多核CPU的优势 随着工业的进步,现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的,4核、8核甚至16核的也都不少见,如果是单线程的程序,那么在双核CPU上就浪费了50%,在4核CPU...
  • 线程与进程的特征及区别定义及特征进程  指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据和堆栈等组成的,是一个能独立运行的活动实体。进程的特征: 1.动态性:进程的实质是程序的一次...
  • java线程与进程

    千次阅读 2018-03-26 12:35:07
    线程:1)进程中负责程序执行的执行单元2)依靠程序执行的顺序控制流,只能使用程序的资源和环境,共享进程的全部资源3)有自己的堆栈和局部变量,没有单独的地址空间4)CPU调度和分派的基本单位,持有程序计数器,...
  • 我不能确保能把它讲的话,也不能确保讲的内容全部都正确。...线程是什么?要理解这个概念,须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式
  • linux线程与进程的理解

    千次阅读 2018-08-21 18:05:03
    首先明确一点,linux对进程线程不做区分,统一由task_struct来管理所有进程线程。 那么如何在linux下区分进程线程呢?   为什么要引入线程的概念? 一个进程包含很多系统资源:进程控制块、虚存空间、...
  • 例子简单了解线程与进程

    千次阅读 2020-03-29 16:11:18
    通过例子简单了解下线程与进程的概念,更多的的是怎么样去理解这两种东西。
  • 进程与线程的一个简单解释 关于线程的理解,同样很生动形象的一个例子。我是一个线程 一. 线程进程与线程的关系 1. 进程是资源管理的最小单位,线程是程序执行的最小单位。 2. 每个进程都有自己的数据...
  • 线程与进程的区别联系?什么是线程安全?
  • 线程与进程的区别联系

    千次阅读 2017-11-30 20:30:29
    1.定义 进程是具有一定独立功能的程序关于某个...线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可同属一个进程的其他的线程共享进程所拥有的全部资源.
1 2 3 4 5 ... 20
收藏数 735,644
精华内容 294,257
关键字:

线程与进程