精华内容
下载资源
问答
  • Java线程的6种状态及切换(透彻讲解)

    万次阅读 多人点赞 2016-12-24 16:57:03
    Java中线程状态分为6。 1. 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。 2. 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。 线程对象创建后,...

    Java中线程的状态分为6种。

    1. 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
    2. 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
    线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
    3. 阻塞(BLOCKED):表示线程阻塞于锁。
    4. 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
    5. 超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回。
    6. 终止(TERMINATED):表示该线程已经执行完毕。

    这6种状态定义在Thread类的State枚举中,可查看源码进行一一对应。

    一、线程的状态图     线程状态图

    二、状态详细说明

    1. 初始状态(NEW)

    实现Runnable接口和继承Thread可以得到一个线程类,new一个实例出来,线程就进入了初始状态。

    2.1. 就绪状态(RUNNABLE之READY)

    1. 就绪状态只是说你资格运行,调度程序没有挑选到你,你就永远是就绪状态。
    2. 调用线程的start()方法,此线程进入就绪状态。
    3. 当前线程sleep()方法结束,其他线程join()结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入就绪状态。
    4. 当前线程时间片用完了,调用当前线程的yield()方法,当前线程进入就绪状态。
    5. 锁池里的线程拿到对象锁后,进入就绪状态。

    2.2. 运行中状态(RUNNABLE之RUNNING)

    线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

    3. 阻塞状态(BLOCKED)

    阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

    4. 等待(WAITING)

    处于这种状态的线程不会被分配CPU执行时间,它们要等待被显式地唤醒,否则会处于无限期等待的状态。

    5. 超时等待(TIMED_WAITING)

    处于这种状态的线程不会被分配CPU执行时间,不过无须无限期等待被其他线程显示地唤醒,在达到一定时间后它们会自动唤醒。

    6. 终止状态(TERMINATED)

    1. 当线程的run()方法完成时,或者主线程的main()方法完成时,我们就认为它终止了。这个线程对象也许是活的,但是它已经不是一个单独执行的线程。线程一旦终止了,就不能复生。
    2. 在一个终止的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

    三、等待队列

    • 调用obj的wait(), notify()方法前,必须获得obj锁,也就是必须写在synchronized(obj) 代码段内。
    • 与等待队列相关的步骤和图

    1. 线程1获取对象A的锁,正在使用对象A。
    2. 线程1调用对象A的wait()方法。
    3. 线程1释放对象A的锁,并马上进入等待队列。
    4. 锁池里面的对象争抢对象A的锁。
    5. 线程5获得对象A的锁,进入synchronized块,使用对象A。
    6. 线程5调用对象A的notifyAll()方法,唤醒所有线程,所有线程进入同步队列。若线程5调用对象A的notify()方法,则唤醒一个线程,不知道会唤醒谁,被唤醒的那个线程进入同步队列。
    7. notifyAll()方法所在synchronized结束,线程5释放对象A的锁。
    8. 同步队列的线程争抢对象锁,但线程1什么时候能抢到就不知道了。 

    四、同步队列状态

    • 当前线程想调用对象A的同步方法时,发现对象A的锁被别的线程占有,此时当前线程进入同步队列。简言之,同步队列里面放的都是想争夺对象锁的线程。
    • 当一个线程1被另外一个线程2唤醒时,1线程进入同步队列,去争夺对象锁。
    • 同步队列是在同步的环境下才有的概念,一个对象对应一个同步队列
    • 线程等待时间到了或被notify/notifyAll唤醒后,会进入同步队列竞争锁,如果获得锁,进入RUNNABLE状态,否则进入BLOCKED状态等待获取锁。

    五、几个方法的比较

    1. Thread.sleep(long millis),一定是当前线程调用此方法,当前线程进入TIMED_WAITING状态,但不释放对象锁,millis后线程自动苏醒进入就绪状态。作用:给其它线程执行机会的最佳方式。
    2. Thread.yield(),一定是当前线程调用此方法,当前线程放弃获取的CPU时间片,但不释放锁资源,由运行状态变为就绪状态,让OS再次选择线程。作用:让相同优先级的线程轮流执行,但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似,只是不能由用户指定暂停多长时间。
    3. thread.join()/thread.join(long millis),当前线程里调用其它线程t的join方法,当前线程进入WAITING/TIMED_WAITING状态,当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到,当前线程一般情况下进入RUNNABLE状态,也有可能进入BLOCKED状态(因为join是基于wait实现的)。
    4. obj.wait(),当前线程调用对象的wait()方法,当前线程释放对象锁,进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
    5. obj.notify()唤醒在此对象监视器上等待的单个线程,选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
    6. LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态,需要通过LockSupport.unpark(Thread thread)唤醒。

    六、疑问

    1. 等待队列里许许多多的线程都wait()在一个对象上,此时某一线程调用了对象的notify()方法,那唤醒的到底是哪个线程?随机?队列FIFO?or sth else?Java文档就简单的写了句:选择是任意性的(The choice is arbitrary and occurs at the discretion of the implementation)。
    展开全文
  • 线程的5种状态详解

    万次阅读 多人点赞 2018-08-23 11:02:42
    Java中的线程的生命周期大体可分为5种状态。 1.新建(NEW):新创建了一个线程对象。 2.可运行(RUNNABLE):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态线程位于可运行线程池中,...

    Java中的线程的生命周期大体可分为5种状态。

     

    1. 新建(NEW):新创建了一个线程对象。

    2. 可运行(RUNNABLE):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。

    3. 运行(RUNNING):可运行状态(runnable)的线程获得了cpu 时间片(timeslice) ,执行程序代码。
    4. 阻塞(BLOCKED):阻塞状态是指线程因为某种原因放弃了cpu 使用权,也即让出了cpu timeslice,暂时停止运行。直到线程进入可运行(runnable)状态,才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种: 

    (一). 等待阻塞:运行(running)的线程执行o.wait()方法,JVM会把该线程放入等待队列(waitting queue)中。
    (二). 同步阻塞:运行(running)的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池(lock pool)中。
    (三). 其他阻塞:运行(running)的线程执行Thread.sleep(long ms)或t.join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入可运行(runnable)状态。

    5. 死亡(DEAD):线程run()、main() 方法执行结束,或者因异常退出了run()方法,则该线程结束生命周期。死亡的线程不可再次复生。

     

     

    一.线程的状态图

         线程状态转换

     

    二.初始状态

    1. 实现Runnable接口和继承Thread可以得到一个线程类,new一个实例出来,线程就进入了初始状态

    三.可运行状态

    1. 可运行状态只是说你资格运行,调度程序没有挑选到你,你就永远是可运行状态。
    2. 调用线程的start()方法,此线程进入可运行状态。
    3. 当前线程sleep()方法结束,其他线程join()结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入可运行状态。
    4. 当前线程时间片用完了,调用当前线程的yield()方法,当前线程进入可运行状态。
    5. 锁池里的线程拿到对象锁后,进入可运行状态。

    四.运行状态

    1. 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

    五.死亡状态

    1. 当线程的run()方法完成时,或者主线程的main()方法完成时,我们就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。
    2. 在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

    六.阻塞状态

    1. 当前线程T调用Thread.sleep()方法,当前线程进入阻塞状态。
    2. 运行在当前线程里的其它线程t2调用join()方法,当前线程进入阻塞状态。
    3. 等待用户输入的时候,当前线程进入阻塞状态。

    七.等待队列(本是Object里的方法,但影响了线程)

    1. 调用obj的wait(), notify()方法前,必须获得obj锁,也就是必须写在synchronized(obj) 代码段内。
    2. 与等待队列相关的步骤和图
    • 线程1获取对象A的锁,正在使用对象A。
    • 线程1调用对象A的wait()方法。
    • 线程1释放对象A的锁,并马上进入等待队列。
    • 锁池里面的对象争抢对象A的锁。
    • 线程5获得对象A的锁,进入synchronized块,使用对象A。
    • 线程5调用对象A的notifyAll()方法,唤醒所有线程,所有线程进入锁池。||||| 线程5调用对象A的notify()方法,唤醒一个线程,不知道会唤醒谁,被唤醒的那个线程进入锁池。
    • notifyAll()方法所在synchronized结束,线程5释放对象A的锁。
    • 锁池里面的线程争抢对象锁,但线程1什么时候能抢到就不知道了。||||| 原本锁池+第6步被唤醒的线程一起争抢对象锁。多线程等待队列

     

    八.锁池状态

    1. 当前线程想调用对象A的同步方法时,发现对象A的锁被别的线程占有,此时当前线程进入锁池状态。简言之,锁池里面放的都是想争夺对象锁的线程。
    2. 当一个线程1被另外一个线程2唤醒时,1线程进入锁池状态,去争夺对象锁。
    3. 锁池是在同步的环境下才有的概念,一个对象对应一个锁池。

    九.几个方法的比较

    1. Thread.sleep(long millis),一定是当前线程调用此方法,当前线程进入阻塞,但不释放对象锁,millis后线程自动苏醒进入可运行状态。作用:给其它线程执行机会的最佳方式。
    2. Thread.yield(),一定是当前线程调用此方法,当前线程放弃获取的cpu时间片,由运行状态变会可运行状态,让OS再次选择线程。作用:让相同优先级的线程轮流执行,但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。
    3. t.join()/t.join(long millis),当前线程里调用其它线程1的join方法,当前线程阻塞,但不释放对象锁,直到线程1执行完毕或者millis时间到,当前线程进入可运行状态。
    4. obj.wait(),当前线程调用对象的wait()方法,当前线程释放对象锁,进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。
    5. obj.notify()唤醒在此对象监视器上等待的单个线程,选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

     

    线程状态:

        

    线程从创建、运行到结束总是处于下面五个状态之一:新建状态、就绪状态、运行状态、阻塞状态及死亡状态。


        1.新建状态(New): 
            当用new操作符创建一个线程时, 例如new Thread(r),线程还没有开始运行,此时线程处在新建状态。 当一个线程处于新生状态时,程序还没有开始运行线程中的代码

         2.就绪状态(Runnable)

            一个新创建的线程并不自动开始运行,要执行线程,必须调用线程的start()方法。当线程对象调用start()方法即启动了线程,start()方法创建线程运行的系统资源,并调度线程运行run()方法。当start()方法返回后,线程就处于就绪状态。

            处于就绪状态的线程并不一定立即运行run()方法,线程还必须同其他线程竞争CPU时间,只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中,不可能同时运行多个线程,一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。


        3.运行状态(Running)

            当线程获得CPU时间后,它才进入运行状态,真正开始执行run()方法.

        4. 阻塞状态(Blocked)

            线程运行过程中,可能由于各种原因进入阻塞状态:
            1>线程通过调用sleep方法进入睡眠状态;
            2>线程调用一个在I/O上被阻塞的操作,即该操作在输入输出操作完成之前不会返回到它的调用者;
            3>线程试图得到一个锁,而该锁正被其他线程持有;
            4>线程在等待某个触发条件;
            ......           
            所谓阻塞状态是正在运行的线程没有运行结束,暂时让出CPU,这时其他处于就绪状态的线程就可以获得CPU时间,进入运行状态。

        5. 死亡状态(Dead)

            有两个原因会导致线程死亡:
             1) run方法正常退出而自然死亡,
             2) 一个未捕获的异常终止了run方法而使线程猝死。
            为了确定线程在当前是否存活着(就是要么是可运行的,要么是被阻塞了),需要使用isAlive方法。如果是可运行或被阻塞,这个方法返回true; 如果线程仍旧是new状态且不是可运行的, 或者线程死亡了,则返回false.

     

    展开全文
  • 介绍Java8中Thread(线程)定义的6种状态,并和传统线程模型的三种/五种状态进行对比

    使用版本为Java8

    Java的6种线程状态

    Java线程状态定义于java.lang.Thread.State,共6种状态:

    状态定义状态名解释
    NEW初始构造一个线程实例后、启动前,线程处于该状态(任何方式创建都是如此,点击可查看线程创建方法
    RUNNABLE就绪/运行该状态包含了经典线程模型的两种状态:就绪(Ready)、运行(Running):
    -------------------
    就绪状态表示有资格运行,但如果一直没拿到时间片,就一直是就绪状态
    * 初始状态的线程,start()方法被调用后,就进入RUNNABLE状态,表示就绪(Ready);并开始等待CPU时间片;
    * 等待或阻塞状态结束,如sleep()结束、或其他线程join()结束、拿到锁,也会进入就绪状态
    * 线程时间片用完,线程的yield()方法会被调用,线程随即进入就绪状态
    -------------------
    当线程调度选中该线程、并分配了CPU时间片后,该线程尽管处于Runnable状态,但实际上是运行(Running);
    * 这是线程进入运行状态的唯一方式
    BLOCKED阻塞通常与锁有关系,表示线程正在获取有锁控制的资源,比如进入synchronized代码块,获取ReentryLock等
    WAITING等待进入该状态的线程,等待被显式唤醒(其他线程发出通知或中断,如notify/notifyAll, 或者另外的线程终止如join的情况),否则处于无限期等待
    TIMED_WAITING超时等待该状态不同于WAITING,它可以在指定的时间后自动唤醒;
    * 处于这种状态的线程不会被分配CPU执行时间;
    * Thread.sleep()执行后,线程就会进入该状态
    TERMINATED终止表示该线程已经执行完毕;
    * 线程Run方法体结束、或主线程(守护线程)的main()方法完成时,线程就认为终止了;
    * 线程对象可能还存活,但不再是单独执行的线程
    * 终止的线程不允许再调用Thread.start()方法

    传统线程模型的3种或5种状态

    三种状态:就绪、运行、等待
    五种状态:新建、就绪、运行、等待、退出

    上面已经把RUNNABLE拆解成就绪和运行状态,另外Java的BLOCKEDWAITINGTIMED_WAITING都属于传统模型的等待状态。

    以上。感谢您的阅读。

    展开全文
  • 1、新状态线程对象已经创建,还没有在其上调用start()方法。 2、可运行状态:当线程有资格运行,但调度程序还没有把它选定为运行线程线程所处的状态。当start()方法调用时,线程首先进入可运行状态。在线程...

    1、新状态:线程对象已经创建,还没有在其上调用start()方法。

    2、可运行状态:当线程有资格运行,但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时,线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。

    3、运行状态:线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

    4、等待/阻塞/睡眠状态:这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种,其共同点是:线程仍旧是活的,但是当前没有条件运行。换句话说,它是可运行的,但是如果某件事件出现,他可能返回到可运行状态。

    5、死亡态:当线程的run()方法完成时就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

    原文链接:http://www.cnblogs.com/garfieldcgf/p/5518929.html
    展开全文
  • Java线程线程的五种状态

    千次阅读 2016-10-11 14:17:48
    线程的 5 中状态 1. New 新建状态 当程序使用 new 关键字创建了一个线程后,该线程就处于新建状态,此时线程还未启劢, 当线程对象调用 start()方法时,线程启劢,迚入 Runnable 状态 2. Runnable 可运行(就绪...
  • 详细介绍了Java线程的6种状态,以及状态之间的转换。
  • 线程5种状态及常见问题

    千次阅读 2017-10-19 18:22:05
    线程的5种状态:  每个 Java 程序都有一个缺省的主线程,对于 Java 应用程序,主线程是 main()方法执行的线索; 对于 Applet 程序,主线程是指挥浏览器加载并执行 Java Applet 程序的线索。要想...
  • 线程的六种状态及其状态的转换

    万次阅读 2018-10-04 18:15:26
    1.线程自身信息 线程运行的过程会产生很多信息,这些信息都保... 线程的优先级:getPriority,线程优先级从1-10,其中数字越大表示优先级别越高,同时获得JVM调度执行的可能性越大,JDK内置了三种常见的状态: //...
  • Java 线程的七种状态

    千次阅读 2019-09-26 19:31:10
    Java 线程状态转换图 Java 线程状态 在 Java 线程的生命周期中,按复杂的并发场景考虑,可将 Java 线程的状态分为七,分别是:新建(New),可运行(Runnable 或 Ready),运行(Running),无限期等待(Waiting...
  • Java线程的6种状态

    千次阅读 2019-05-26 15:46:56
    Java的线程大致有6种状态: NEW: 新建状态,new了一个线程。 Runable: 可执行状态线程调用了start()或run()方法,或者等待结束,都会进入Runable状态,在操作系统或处理器而言,java的Runable状态可能是他们...
  • 守护线程及六种线程状态简介

    千次阅读 热门讨论 2020-03-03 18:55:10
    守护线程及六种线程状态简介 1. 守护线程 守护线程一般用于: 1. 自动下载 2. 操作日志 3. 操作监控 方法是通过线程对象 setDeamon(boolean flag); true为守护线程 false缺省属性,正常线程 2. 线程状态 ...
  • 线程的几种状态

    千次阅读 2018-08-15 22:24:57
    1. 线程的几种状态 初始状态:是指线程刚刚创建,尚未启动,还没有调start()方法 运行状态:分为就绪和运行中状态 就绪:线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态线程...
  • Java多线程03_线程状态、优先级、用户线程和守护线程 线程方法: setPriority() 更改线程优先级 static void sleep() 线程休眠 void join() 插队 static void yield() 礼让 void interrupt() 中断...
  • Python 线程的五种状态、守护线程

    千次阅读 2019-08-20 11:07:49
    一、线程的五种状态 大多数线程的生命周期经历有 新建、就绪、运行、阻塞、死亡 这五种状态,对于多线程来说,一个线程不可能始终霸占着CPU,CPU需要在不同线程之间切换,于是线程状态也会随之改变。 1.新建 当...
  • 线程有哪些状态

    千次阅读 2019-05-14 12:16:58
    线程有哪些状态? 新建(NEW):新建线程对象,未调用 start 方法 可运行(RUNNABLE):线程对象创建后,被调用 start 方法。此状态线程位于可运行线程池中,等待获取 CPU 的使用权 运行中(RUNNING):线程获取了 ...
  • 简述线程的几种状态以及状态之间的转换

    千次阅读 多人点赞 2019-08-23 21:38:24
    线程有以下几种状态 1、new 新建状态(此时线程刚被new出来,还没执行start()方法) 2、Runable运行状态,有执行资格又有执行权,但它可能正在等待来自操作系统的其他资源,例如处理器。 3、Blocked 阻塞状态,也...
  • java多线程的几种状态

    万次阅读 2018-09-04 13:00:38
    Java线程既可以创建,也可以销毁,所以线程是有生命周期的,而线程的生命周期就可以用线程的六种状态来描述。 从Thread类的源码中可以看出线程一共有6种状态: 这六种状态分别是: 1. New:初始状态线程被创建...
  • 线程的几种状态转换

    万次阅读 多人点赞 2016-09-17 20:49:17
    线程一共有以下几种状态: 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态线程位于“可运行线程池”中,变得可运行,只等待获取...
  • Java线程到底有几种状态

    千次阅读 2019-08-19 23:14:06
    前言 很多文章说Java线程有五状态:NEW(新建)、RUNNABLE(就绪)、RUNNING(运行)、BLOCKED(阻塞)...线程状态 Java线程到底有几状态,其实只要打开一下JDK源码,看一下java.lang.Thread类就知道了,java.l...
  • 线程状态与调度

    万次阅读 2021-03-10 20:59:49
    当我们使用new关键字新建一个线程,这个时候线程就进入了新建状态(New),也就是图中未启动状态;...阻塞的情况分三种; 等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。(wa..
  • 线程状态:   线程从创建、运行到结束总是处于下面五个状态之一:新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 1.新建状态(New): 当用new操作符创建一个线程时, 例如new Thread(r),线程还没有...
  • 02. 线程的五种状态

    千次阅读 2019-09-01 18:52:47
    线程启动后, 不可能一直霸占着CPU 独自运行, CPU 需要在多个线程之间切换, 因此线程状态也就会在运行, 就绪之间来回切换. 1.1 线程的五状态之间的转换 新建状态: 通过new 创建线程后, 线程便进入了新建状态 ...
  • 线程有六种状态: new(新创建),runnable(可运行),blocked(被阻塞),waiting(等待),timed waiting(计时等待),terminated(被终止) 几方法的比较: void interrupt() 向线程发送中断请求。线程的中断状态将被置为...
  • 线程及线程池的五种状态

    千次阅读 2019-06-21 16:14:27
    线程的5种状态 线程可以有如下5种状态:New 、Runnable 、Running 、Blocked 、Dead 状态之间的转换如图: 1.New (新创建) 当用new操作符创建一个线程时,如new Thread®,该线程还没有开始运行。这意外这它的状态...
  • Java线程的几种状态

    千次阅读 2016-09-12 13:47:00
    1. 程序通过Thread t = new Thread(),调用t.start()启动一个线程,使该线程进入可运行(Runnable)的状态。 2. 由JVM的决定去调度(Scheduler) 在可运行状态(Runnable)下的线程,使该线程处于运行 (Running) ...
  • 一、线程的四种状态 新建(new):处于该状态的时间很短暂。已被分配了必须的系统资源,并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态 就绪(Runnable):这种状态下...
  • 线程状态 Thread.State 状态类型 在指定的时间点, 一个线程有且只有一状态。 这些状态是 JVM 的状态, 他们并没有反映操作系统的状态。 定义 Thread 的状态是定义在 Thread 内部的枚举类型。...
  • java 线程有几种状态

    千次阅读 2015-04-29 08:35:29
    在java中,线程通常有五种状态,创建,就绪,运行、阻塞和死亡状态。  第一是创建状态。在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。  第二是就绪状态。当调用了线程对象的start...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,049,773
精华内容 419,909
关键字:

线程的三种状态