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

	}
}