高手的存在,就是让服务10亿人的时候,你感觉只是为你一个人服务......

java线程状态学习

目录
  1. 1. 可以直接看java.lang.Thread.State类,里面对几种状态有详细解释。
  2. 2. 下面我们来写写代码,让这些线程进入以上几种状态:
    1. 2.1. NEW,这个比较easy:
    2. 2.2. RUNABLE,也easy,将线程start,同时代码里面不要wait或者sleep
    3. 2.3. BLOCKED,这个需要至少两个线程,然后互相等待synchronized
    4. 2.4. WAITING,这个需要用到生产者消费者模型, 当生产者生产过慢的时候, 消费者就会等待生产者的下一次notify
  3. 3. TIMED_WAITING, 这个仅需要在4的基础上, 在wait方法加上一个时间参数进行限制就OK了
    1. 3.1. TERMINATED, 这个状态只要线程结束了run方法, 就会进入了

一直对java线程的几种状态认识的模模糊糊,平时在对java进行监控的时候,用jstack打出一堆线程状态,看的不是很懂,另外网上一堆乌七八糟的东西,看着着实难受,自己学习一下,整理整理。

可以直接看java.lang.Thread.State类,里面对几种状态有详细解释。

NEW 状态是指线程刚创建, 尚未启动

RUNNABLE 状态是线程正在正常运行中, 当然可能会有某种耗时计算/IO等待的操作/CPU时间片切换等, 这个状态下发生的等待一般是其他系统资源, 而不是锁, Sleep等

BLOCKED 这个状态下, 是在多个线程有同步操作的场景, 比如正在等待另一个线程的synchronized 块的执行释放, 或者可重入的 synchronized块里别人调用wait() 方法, 也就是这里是线程在等待进入临界区

WAITING 这个状态下是指线程拥有了某个锁之后, 调用了他的wait方法, 等待其他线程/锁拥有者调用 notify / notifyAll 一遍该线程可以继续下一步操作, 这里要区分 BLOCKED 和 WATING 的区别, 一个是在临界点外面等待进入. 一个是在理解点里面wait等待别人notify, 线程调用了join方法 join了另外的线程的时候, 也会进入WAITING状态,等待被他join的线程执行结束

TIMED_WAITING 这个状态就是有限的(时间限制)的WAITING, 一般出现在调用wait(long), join(long)等情况下, 另外一个线程sleep后, 也会进入TIMED_WAITING状态

TERMINATED 这个状态下表示 该线程的run方法已经执行完毕了, 基本上就等于死亡了(当时如果线程被持久持有, 可能不会被回收)


上面的几段话仔细读一读,想一想

下面我们来写写代码,让这些线程进入以上几种状态:

NEW,这个比较easy:

1
2
Thread thread = new Thread();
System.out.println(thread.getState());

输出NEW

RUNABLE,也easy,将线程start,同时代码里面不要wait或者sleep

1
2
3
4
5
6
7
8
9
10
Thread thread = new Thread() {
@Override
public void run() {

for (int i = 0; i <= 10; i++) {
System.out.println(currentThread().getState());
}
}

};
thread.start();

输出:

RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
RUNNABLE
Alt text

BLOCKED,这个需要至少两个线程,然后互相等待synchronized

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
final Object lock = new Object();

Thread run = new Thread() {
@Override
public void run() {
for (int i = 0; i <= 10; i++) {
synchronized (lock) {
System.out.println(currentThread().getState());
}
}
}

};

Thread t1 = new Thread(run);
t1.setName( “t1”);
Thread t2 = new Thread(run);
t2.setName( “t2”);
t1.start();
t2.start();

Alt text
这时候, 一个在RUNNABLE, 另一个就会在BLOCKED (等待另一个线程的 System.out.println.. 这是个IO操作, 属于系统资源, 不会造成WAITING

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
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();

Alt text

TIMED_WAITING, 这个仅需要在4的基础上, 在wait方法加上一个时间参数进行限制就OK了

1
2
3
4
5
6
7
synchronized (lock) {
try {
lock.wait(60 * 1000L);
} catch (InterruptedException e) {
}
System. out .println(i++);
}

Alt text

另外看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();
}

Alt text
t2的state是 TIMED_WAITING( sleeping), 而t1依然是on object monitor , 因为t1还是wait在等待t2 notify, 而t2是自己sleep

TERMINATED, 这个状态只要线程结束了run方法, 就会进入了