在我们平时写code的时候，经常会使用到多线程。其中线程所处的状态就是我们需要进程思考的问题。
- 线程有哪些状态
NEW: 一个线程刚被创建，但是没有被使用就是处于这个状态
RUNNABLE: 一个线程正在jvm虚拟机中被执行就是处于这个状态
BLOCKED：一个线程等待一个moniter，就是处于这个状态.
WAITING：一个线程无休止的等待另一个线程就是处于这个状态
TIMED_WAITING：一个线程等待林一个线程，但是有具体的timeout，就是处理这个状态
TERMINATED：一个线程执行结束了，就是处于这个状态
public class Hello {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
Object lock2 = new Object();
// NEW
Thread test = new Thread();
// RUNNABLE
Thread test1 = new Thread(() -> {
int i = 0;
synchronized (lock){
while (true) {
i++;
}
}
});
// BLOCK
Thread test2 = new Thread(() -> {
int i = 0;
synchronized (lock){
while (true) {
i++;
}
}
});
// Waiting
Thread test3 = new Thread(() -> {
int i = 0;
synchronized (lock2){
try {
lock2.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
// Time_waiting -----3s--> TERMINATED
Thread test4 = new Thread(() -> {
int i = 0;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
test1.start();
test2.start();
test3.start();
test4.start();
Thread.sleep(1000);
System.out.println(test1.getState());
System.out.println(test2.getState());
System.out.println(test3.getState());
System.out.println(test4.getState());
Thread.sleep(3000);
System.out.println(test4.getState());
}
}
-
状态的转换
-
BLOCKED： 进入同步块/方法，等待获取monitor。或者调用Object.wait之后被notify唤醒，但是没有获取monitor。
- Waiting:
- Object.wait with no timeout
- Thread.join with no timeout
- LockSupport.park
- Timed_waiting:
- Thread.sleep
- Object.wait with timeout
- Thread.join with timeout
- LockSupport.parkNanos
- LockSupport.parkUntil
package com.hardy.pojo;
public class Hello {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
Thread test1 = new Thread(() -> {
synchronized (lock){
try {
System.out.println("test1");
lock.wait();
Thread.sleep(10000);
System.out.println("test1 end");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("end");
}
});
Thread test2 = new Thread(() -> {
synchronized (lock){
System.out.println("test2");
try {
lock.wait();
Thread.sleep(10000);
System.out.println("test2 end");
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("end");
}
});
Thread test3 = new Thread(() -> {
int i = 0;
synchronized (lock){
try {
System.out.println("test3");
lock.notifyAll(); // 这里是notifyAll会唤醒所有的wait线程。但是线程都是需要monitor的，monitor只能被一个线程持有。所以notifyAll之后，一个线程变成Runable,一个线程变成Block
System.out.println("test3 end");
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("end");
}
});
test1.start();
test2.start();
Thread.sleep(1000);
test3.start();
Thread.sleep(1000);
System.out.println(test1.getState());
System.out.println(test2.getState());
System.out.println(test3.getState());
}
}
思考：如果notifyAll变成notify，那么另外两个线程的状态如何改变？
Original: https://www.cnblogs.com/hardyzhou/p/16600369.html
Author: hardyzhou
Title: Java的线程状态
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/585150/
转载文章受原作者版权保护。转载请注明原作者出处！