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

	}
}