java 线程的几种状态
java thread的运行周期中, 有几种状态, 在 java.lang.Thread.State 中有详细定义和说明:
NEW 状态是指线程刚创建, 尚未启动
RUNNABLE 状态是线程正在正常运行中, 当然可能会有某种耗时计算/IO等待的操作/CPU时间片切换等, 这个状态下发生的等待一般是其他系统资源, 而不是锁, Sleep等
WAITING 这个状态下是指线程拥有了某个锁之后, 调用了他的wait方法, 等待其他线程/锁拥有者调用 notify / notifyAll 一遍该线程可以继续下一步操作, 这里要区分 BLOCKED 和 WATING 的区别, 一个是在临界点外面等待进入, 一个是在临界点里面wait等待别人notify, 线程调用了join方法 join了另外的线程的时候, 也会进入WAITING状态, 等待被他join的线程执行结束
TIMED_WAITING 这个状态就是有限的(时间限制)的WAITING, 一般出现在调用wait(long), join(long)等情况下, 另外一个线程sleep后, 也会进入TIMED_WAITING状态
TERMINATED 这个状态下表示 该线程的run方法已经执行完毕了, 基本上就等于死亡了(当时如果线程被持久持有, 可能不会被回收)
下面谈谈如何让线程进入以上几种状态:
1. NEW
|
1 2 3 4 |
static void NEW() { Thread t = new Thread (); System. out.println(t.getState()); } |
2. RUNNABLE
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
private static void RUNNABLE() { Thread t = new Thread(){ public void run(){ for(int i=0; i<Integer.MAX_VALUE; i++){ System. out.println(i); } } }; t.start(); } |
3. BLOCKED
这个就必须至少两个线程以上, 然后互相等待synchronized 块
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
private static void BLOCKED() { final Object lock = new Object(); Runnable run = new Runnable() { @Override public void run() { for(int i=0; i<Integer.MAX_VALUE; i++){ synchronized (lock) { System. out.println(i); } } } }; Thread t1 = new Thread(run); t1.setName( “t1”); Thread t2 = new Thread(run); t2.setName( “t2”); t1.start(); t2.start(); } |
4. WAITING,
这个需要用到生产者消费者模型, 当生产者生产过慢的时候, 消费者就会等待生产者的下一次notify
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
private static void WAITING() { final Object lock = new Object(); Thread t1 = new Thread(){ @Override public void run() { int i = 0; while(true ){ synchronized (lock) { try { lock.wait(); } catch (InterruptedException e) { } System. out.println(i++); } } } }; Thread t2 = new Thread(){ @Override public void run() { while(true ){ synchronized (lock) { for(int i = 0; i< 10000000; i++){ System. out.println(i); } lock.notifyAll(); } } } }; t1.setName( “^^t1^^”); t2.setName( “^^t2^^”); t1.start(); t2.start(); } |
5.TIMED_WAITING
这个仅需要在4的基础上, 在wait方法加上一个时间参数进行限制就OK了.把4中的synchronized 块改成如下就可以了.
|
1 2 3 4 5 6 7 |
synchronized (lock) { try { lock.wait(60 * 1000L); } catch (InterruptedException e) { } System. out .println(i++); } |
另外看stack的输出, 他叫 TIMED_WAITING(on object monitor) , 说明括号后面还有其他的情况, 比如sleep, 我们直接把t2的for循环改成sleep试试:
|
1 2 3 4 5 6 7 8 |
synchronized (lock) { try { sleep(30*1000L); } catch (InterruptedException e) { } lock.notifyAll(); } |
6.TERMINATED
这个状态只要线程结束了run方法, 就会进入了…
|
1 2 3 4 5 6 7 8 9 10 |
private static void TERMINATED() { Thread t1 = new Thread(); t1.start(); System. out.println(t1.getState()); try { Thread. sleep(1000L); } catch (InterruptedException e) { } System. out.println(t1.getState()); } |