首页 > 试题广场 >

概括的解释下线程的几种可用状态。

[问答题]
概括的解释下线程的几种可用状态。
添加回答
推荐
冷冰冰头像 冷冰冰
1. 新建( new )：新创建了一个线程对象。
2. 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取 cpu 的使用权 。
3. 运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。
4. 阻塞( block )：阻塞状态是指线程因为某种原因放弃了 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 ()方法，则该线程结束生命周期。死亡的线程不可再次复生。

编辑于 2015-12-18 11:33:28 回复(7)
Circle&Z头像 Circle&Z
可以用早起坐地铁来比喻这个过程：
还没起床：sleeping
起床收拾好了，随时可以坐地铁出发：Runnable
等地铁来：Waiting
地铁来了，但要排队上地铁：I/O阻塞
上了地铁，发现暂时没座位：synchronized阻塞
地铁上找到座位：Running
到达目的地：Dead
发表于 2015-12-18 10:07:35 回复(31)
Thas头像 Thas

操作系统线程的5种状态：

  1. 新建状态：
    线程创建但没有启动
  2. 就绪状态：
    线程处于可运行的状态，当线程获得CPU的时间片后会被执行，时间片耗尽或主动放弃当次时间片（yield方法）时再次进入就绪状态。
  3. 运行状态：
    线程得到时间片被CPU执行
  4. 阻塞状态：
    线程放弃CPU的时间片（一直到某个条件达成），主动进入阻塞的状态。
  • 同步阻塞：线程由于尝试获得对象的同步锁但无法取得时，进入锁池，等待其他线程释放该对象的锁。
  • 等待阻塞：线程主动放弃对对象上的锁的占用，进入等待对象通知的队列。指wait方法
  • 其他阻塞：线程主动进入休眠状态，等待条件达成。指sleep、join方法或I/O请求。
  1. 终止状态：
    线程任务结束或异常退出

Java线程定义的6种状态：

  1. 新建状态NEW：
    线程创建，但没有启动
  2. 可运行状态（就绪状态）RUNNABLE： 代表线程正在运行或者不处于阻塞、等待状态的可以被运行的状态。线程创建后或脱离阻塞、等待状态后进入可运行状态。
  3. 阻塞状态BLOCKED：
    代表线程尝试获得一个锁时无法对锁占用，进入阻塞状态；当该线程能够获得锁时脱离阻塞状态。
  4. 等待状态WAITING：
    等待线程主动进入等待条件达成的状态，可以使用join、wait、sleep方法。
  5. 计时等待状态TIMED_WAITING：
    等待状态添加计时器，当等待条件达成或计时器耗尽时脱离等待状态。
  6. 中断状态（终止状态）TERMINATED：
    线程任务结束或手动设置中断标记
发表于 2019-01-17 19:37:52 回复(0)
zll头像 zll
新建
可运行
运行
阻塞：
等待阻塞（执行wait（）方法）
同步阻塞（锁机制）
其它阻塞（执行sleep（）方法，t.join（）方法，执行I/O请求）
死亡
发表于 2016-03-19 13:29:44 回复(2)
老铁好好干啊头像 老铁好好干啊
比较重要的几点需要注意：
1 sleep和yield的区别在于, sleep可以使优先级低的线程得到执行的机会,  而yield只能使同优先级的线程有执行的机会.
2 interrupt方法不会中断一个正在运行的线程.就是指线程如果正在运行的过程中, 去调用此方法是没有任何反应的. 为什么呢, 因为这个方法只是提供给 被阻塞的线程, 即当线程调用了.Object.wait, Thread.join, Thread.sleep三种方法之一的时候, 再调用interrupt方法, 才可以中断刚才的阻塞而继续去执行线程.
3 join()  当join(0)时等待一个线程执行直到它死亡返回主线程,  当join(1000)时主线程等待一个线程1000纳秒,后回到主线程继续执行.
4 waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

 

发表于 2017-07-20 09:18:58 回复(1)
找工作的飞鱼头像 找工作的飞鱼

新建态：当创建一个线程对象时，线程处于新建态，在堆中开辟空间，设置线程名和优先级，优先级不设定则默认为5级，与主线程平级。且在就绪状态后就不能更改 从寄存器拿到栈空间地址和计数器地址

就绪态： 就绪池中存放了多个就绪态线程，从寄存器拿到栈空间地址和计数器地址，分配处理机，进入运行态。

(1)  调用线程的start( )方法，此线程进入就绪态

(2)  当前线程sleep( )方法结束，其他线程join( )结束，等待用户输入完毕，某个线程拿到对象锁，这些线程进入了就绪状态

(3)  当前线程时间片用完，调用当前线程的yield( )方法，当前线程进入就绪态。

(4)  锁池中的对象拿到对象锁后

运行态：线程调度程序从就绪池中选择一个就绪态线程分配处理机，使线程处于运行态，这是线程进入运行态的唯一方式。

阻塞态：重新分配处理机，不会释放资源，将指令计数器的位置和栈的地址给寄存器

(1)  调用sleep()方法

(2)  给方法或者代码块加锁，(Synchronized关键字修饰)

(3)  读取键盘内容，光标等待的时候

(4)  进入等待池

死亡态：线程终止，释放占用的资源

(1)  run()或者main()执行完成时，线程终止进入死亡状态

(2)  被另外线程强制死亡

(3)  当终止线程调用start方法，出现java.lang.IllegalThreadStateException异常

发表于 2019-09-04 19:53:45 回复(0)
漂亮的反击头像 漂亮的反击
有5个状态：1、创建状态，新建一个线程对象可用Thread类的构造方法来实现，Thread thread=new Thread(); 2、就绪状态，新建线程对象后，调用该线程的start（）方法就可以启动线程。当线程启动后，进入了就绪状态； 3、运行状态，当就绪状态的线程被调用并获得处理器资源时，线程进入运行状态，此时会调用run()方法； 4、堵塞状态，在可执行的情况下，调用wait()、sleep() 、suspend（）等方***使线程进入堵塞状态，当堵塞消除后，线程进入就绪状态； 5、死亡状态，线程调用stop()方法或者run()方法执行结束后，处于死亡状态。有不足之处，希望大家批评指正。
发表于 2018-06-28 11:20:17 回复(0)
牛客165600号头像 牛客165600号
new 新创建一个线程对象 runnable 该线程位于可运行线程池中，等待被线程调度选中，获取cpu使用权。start() running 等待线程获得timeslie block
发表于 2016-09-02 08:36:25 回复(0)
雅风头像 雅风
1. 新建( new )：新创建了一个线程对象。 2. 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取 cpu 的使用权 。 3. 运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。 4. 阻塞( block )：阻塞状态是指线程因为某种原因放弃了 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 ()方法，则该线程结束生命周期。死亡的线程不可再次复生。
发表于 2016-09-01 23:43:04 回复(0)
Nan头像 Nan
线程在执行过程中，可以处于下面几种状态：
就绪(Runnable):线程准备运行，不一定立马就能开始执行。
运行中(Running)：进程正在执行线程的代码。
等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
睡眠中(Sleeping)：线程被强制睡眠。
I/O阻塞(Blocked on I/O)：等待I/O操作完成。
同步阻塞(Blocked on Synchronization)：等待获取锁。
死亡(Dead)：线程完成了执行。
发表于 2015-10-29 12:10:41 回复(0)
黄欢头像 黄欢
一张图
发表于 2021-07-18 12:51:08 回复(0)
客串一回头像 客串一回
发现问题：Thread.join本质上是无限wait，无视notify的无限循环wait调用

发表于 2021-07-03 11:19:44 回复(0)
説头像 説
新建态 就绪态 运行态 死亡态 阻塞态
发表于 2021-05-14 10:55:40 回复(0)
Tod_头像 Tod_
1. 新建New 2. 就绪Runnable 3. 运行Running 4. 阻塞Block 当一个进程1请求共享资源，而此时共享资源被另一进程2所占用，此时即为同步阻塞，进程1进去wait队列中(等待阻塞)，如果进程2释放该共享资源后，调用NotifyAll方法，在wait队列中取出一个进程使用该共享资源。 进程时间片用完后从运行态转为就绪态 5. 终止Dead
发表于 2021-03-13 00:00:14 回复(0)
我且随风前行头像 我且随风前行
<p>new出一线程对象后，调用start方法进入可运行状态，获取到时间片就进入运行状态，如果调用wait方法就进入等待状态，调用sleep方法，join方法进入阻塞状态，等待时间结束或者notify/All，就会和获取到时间片但没拿到锁对象一样进入锁池，睡眠时间到或者join方法结束也会就会进入到可运行状态，run方法或main方法结束就死亡</p>
发表于 2020-12-07 10:53:24 回复(0)
小猴子的头像 小猴子的
还有一个等待超时状态
发表于 2020-12-03 10:50:33 回复(0)
ikalpa头像 ikalpa
<p>等待，激活，死亡</p><p><br></p>
发表于 2020-10-09 23:23:58 回复(0)
闲着没事就睡觉头像 闲着没事就睡觉
new、 runnable、blocked、waiting、time_waiting、terminated称为线程6个状态。
    new ：线程初始状态，也就是新创建的线程状态。
    runnable：调用start方法后的状态。
    terminated：执行完成（包括出现异常程序终止）的状态。
    blocked：进入synchronized代码块的状态，lock虽然也能锁住代码块，但是这个状态只有遇到    synchronized才会从runnable转为blocked。
    waiting：执行wait(),join(),LockSupport.park()就会从runnable转为waiting；执行notify(),notifyAll()或者LockSupport.unpaik()就会从waiting转为runnable。
    time_waiting ：调用sleep(time),wait(time),join(time),LockSupport.parkNanos(time)或Lock.support.parkUtil(time)就会从Runnable转为time_witing;再等时间到或执行notify(),notifyAll()或者LockSupport.unpark()又会回到Runnable。
注意点：线程执行顺序是不可逆的，一个线程执行终止，要想执行新的任务，就只能重新创建线程，理论上上面我已经说了所有的状态转换方式。但是也有例外。
    1. 比如发生异常，可能直接从waiting,timeWaiting转变为terminated。
    2. 也有可能线程被唤醒后还没抢到monitor锁（可能之前持有锁的线程还没有释放，也有可能被另一个线程抢到），此时这个线程就会进入blocked状态，等拿到锁后会转为Runnable。
非复制粘贴，纯手打，如果有一楼或者说的不对的地方，欢迎指正，共同进步
发表于 2020-09-04 10:39:01 回复(0)
Leeguohui头像 Leeguohui
<p>1.new runnable blocked waiting time_waiting terminated</p><p><br></p>
发表于 2020-09-01 19:18:31 回复(0)
Assassin丶冷靖头像 Assassin丶冷靖
线程的5个状态，1.新建，2.可运行，3.运行，4.阻塞，5.死亡。其中新建状态是废话，可运行和运行时一起的，只是区分调度时间而已。阻塞是为了线程同步或互斥。
编辑于 2020-08-30 11:10:10 回复(0)
牛客788003925号头像 牛客788003925号
由5种线程状态
1.新建状态
通过new一个thread实例，创建一个线程对象 
2.可运行状态
通过实例对象调用start()方法，该线程进入可运行状态，不一定能执行run方法
3.运行状态
该线程被分配，获取到了cpu的时间，这个时候执行run方法。
4.阻塞状态
1.该线程调用了sleep休眠方法
 2线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
 3.线程试图得到一个锁，而该锁正被其他线程持有；
     所谓的阻塞就是该线程让出了cpu的暂用时间，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
5.死亡状态
1.当run方法或者main运行完成后该线程死亡，线程死亡不能复生
发表于 2020-08-29 16:50:57 回复(0)
提交观点

问题信息

Java
上传者：勇敢之心
难度：
74条回答 19413浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号