线程的状态

线程的六种状态。

NEW  :至今尚未启动的线程处于这种状态.(线程创建)

RUNNABLE:正在Java虚拟机中执行的线程处于来执行这种状态.（线程正在执行）

BLOCKED:受阻塞并等待某个监视器锁的线程处于这种状态.（等待其他线程释放锁）

WAITING:无限期的等待另一个线程来执行某一特定操作的线程处于这种状态 .（线程执行了wati()方法）

TIMED_WAITING:等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态.（线程执行了sleep()方法）

TERMINATED:已退出的线程处于这种状态.（线程退出）

1.验证线程的状态： NEW   RUNNABLE  TERMINATED

package State;

public class TestThreadState
{

	public static void main(String[] args) throws InterruptedException
	{
		Thread t = new Thread()
		{
			public void run()
			{
				// RUNNABLE状态
				System.out.println("RUNNABLE ====" + Thread.currentThread().getState());
			};
		};

		// NEW 状态
		System.out.println("NEW ====" + t.getState());

		// 线程启动
		t.start();

		// 确保线程t，执行完毕
		Thread.sleep(1000);

		// TERMINATED 状态
		System.out.println("TERMINATED ====" + t.getState());

	}

}

输出：

总结： NEW 状态，线程创建 ， RUNNABLE：线程正在执行。TERMINATED：线程退出。

2.验证 TIMED_WAITING  （线程执行了sleep()方法）

package State;

public class TestTimedWating
{
	public static void main(String[] args) throws InterruptedException
	{
		Thread t = new Thread()
		{
			@Override
			public void run()
			{
				try
				{
					Thread.sleep(10_000);
				} catch (InterruptedException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};

		t.start();
		t.sleep(1_000);
		System.out.println("TIMED_WAITING====" + t.getState());
	}
}

输出

3.验证BLOCKED(等待其他线程释放锁)

package State;

public class TestBlocked
{

	synchronized public static void test()
	{
		try
		{
			System.out.println(Thread.currentThread().getName());
			Thread.sleep(5_000);
		} catch (InterruptedException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws InterruptedException
	{
		Thread t1 = new Thread()
		{
			public void run()
			{
				test();
			};
		};

		Thread t2 = new Thread()
		{
			public void run()
			{
				test();
			};
		};
		t1.setName("A");
		t1.start();
		t2.setName("B");
		t2.start();
		Thread.sleep(2_000);
            //线程B在等待线程A释放锁
		System.out.println("BLOCKED===" + t2.getState());

	}
}

输出：

4.验证WAITING

package State;

public class TestWaiting
{

	public static Object lock = new Object();

	public static void main(String[] args) throws InterruptedException
	{
		Thread t = new Thread()
		{
			@Override
			public void run()
			{
				try
				{
					synchronized (lock)
					{
						// wait 方法必须在获取锁以后执行 否则抛异常java.lang.IllegalMonitorStateException
						lock.wait();
					}
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		};

		t.start();
		Thread.sleep(2_000);
		System.out.println("WATING===" + t.getState());
	}
}

输出：