java 等待和阻塞_JAVA 线程状态 阻塞和等待 bloked 和 waiting 区别

NEW A thread that has not yet started is in this state.

一个被创建的线程，但是还没有调用start方法

一个正在被执行的线程的状态

RUNNABLE A thread executing in the Java virtual machine is in this state.

一个线程因为等待临界区的锁被阻塞产生的状态

Lock 或者synchronize 关键字产生的状态

BLOCKED A thread that is blocked waiting for a monitor lock is in this state.

一个线程进入了锁，但是需要等待其他线程执行某些操作。时间不确定

WAITING A thread that is waiting indefinitely for another thread to perform a particular action is in this state.

当wait，join，park方法调用时，进入waiting状态。前提是这个线程已经拥有锁了。

一个线程进入了锁，但是需要等待其他线程执行某些操作。时间确定

TIMED_WAITING A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.

通过sleep或wait timeout方法进入的限期等待的状态)

退出

TERMINATED A thread that has exited is in this state.

package com.famous.qingxing.thread;

import java.util.concurrent.CountDownLatch;

public class ThreadStatusBLOCKED {

public static void main(String[] args) {

final Object o = new Object();

final CountDownLatch countDownLatch = new CountDownLatch(1);

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

System.err.println("t1");

synchronized (o) {

countDownLatch.countDown();

while (true) {

if (Thread.currentThread().isInterrupted()) {

System.err.println("break");

break;

}

}

}

}

});

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

try {

System.err.println("'awit");

countDownLatch.await();

System.err.println("awt end");

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (o) {

}

}

});

t1.start();

t2.start();

countDownLatch.countDown();

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

if (t2.getState().toString().equals("BLOCKED")) {

System.err.println("t2 is blocked");

t1.interrupt();

}

}

}

//

package com.famous.qingxing.thread;

import java.util.concurrent.ThreadFactory;

public class ThreadStatusNEW {

public static void main(String[] args) {

Thread t = new Thread(new Runnable() {

@Override

public void run() {

System.err.println("status will be ");

}

});

System.err.println(t.getState());

}

}

class MyThreadFactory implements ThreadFactory {

@Override

public Thread newThread(Runnable r) {

Thread t = new Thread(r);

return t;

}

}

//

package com.famous.qingxing.thread;

import java.util.concurrent.CountDownLatch;

public class ThreadStatusRunnable {

public static void main(String[] args) {

final CountDownLatch countDownLatch = new CountDownLatch(1);

Thread t = new Thread(new Runnable() {

@Override

public void run() {

try {

countDownLatch.await();

System.err.println(Thread.currentThread().getState());

} catch (InterruptedException e) {

e.printStackTrace();

}

System.err.println("status will be " + Thread.currentThread().getState());

}

});

t.start();

countDownLatch.countDown();

}

}

//

package com.famous.qingxing.thread;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ThreadFactory;

public class ThreadStatusTimeWaiting {

public static void main(String[] args) {

final Object object = new Object();

final CountDownLatch countDownLatch = new CountDownLatch(3);

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

synchronized (object) {

try {

countDownLatch.countDown();

Thread.sleep(10000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

});

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

synchronized (object) {

try {

countDownLatch.countDown();

Thread.sleep(10000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

});

t1.start();

t2.start();

try {

countDownLatch.countDown();

System.err.println(t1.getState());

System.err.println(t2.getState());

} catch (Exception e) {

e.printStackTrace();

}

}

}

//

package com.famous.qingxing.thread;

import java.util.concurrent.CountDownLatch;

public class ThreadStatusWaiting {

public static void main(String[] args) {

final Object o = new Object();

final CountDownLatch countDownLatch = new CountDownLatch(1);

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

System.err.println("t1");

synchronized (o) {

countDownLatch.countDown();

while (true) {

if (Thread.currentThread().isInterrupted()) {

System.err.println("break");

break;

}

}

}

}

});

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

try {

System.err.println("'awit");

countDownLatch.await();

System.err.println("awt end");

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (o) {

}

}

});

t1.start();

t2.start();

countDownLatch.countDown();

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

if (t2.getState().toString().equals("BLOCKED")) {

System.err.println("t2 is blocked");

t1.interrupt();

}

}

}