Java知识点——线程的状态

线程的状态

Java知识点——线程的状态

初始态：

NEW创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。

运行态：

RUNNABLE在Java中，运行态包括就绪态和运行态。

就绪态
- 该状态下的线程已经获得执行所需的所有资源，只要CPU分配执行权就能运行。
- 所有就绪态的线程存放在就绪队列中。
运行态
- 获得CPU执行权，正在执行的线程。
- 由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条运行态的线程。

阻塞态

当一条正在执行的线程请求某一资源失败时，就会进入阻塞态。
而在Java中，阻塞态专指请求锁失败时进入的状态。
由一个阻塞队列存放所有阻塞态的线程。
处于阻塞态的线程会不断请求资源，一旦请求成功，就会进入就绪队列，等待执行。

PS：锁、IO、Socket等都资源。

等待态

当前线程中调用wait、join、park函数时，当前线程就会进入等待态。
也有一个等待队列存放所有等待态的线程。
线程处于等待态表示它需要等待其他线程的指示才能继续运行。
进入等待态的线程会释放CPU执行权，并释放资源（如：锁）

超时等待态

当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时，就会进入该状态；
它和等待态一样，并不是因为请求不到资源，而是主动进入，并且进入后需要其他线程唤醒；
进入该状态后释放CPU执行权和占有的资源。
与等待态的区别：到了超时时间后自动进入阻塞队列，开始竞争锁。

终止态

线程执行结束后的状态。

package threadDemo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadStatus {
	private static Lock lock = new ReentrantLock();
	public static void main(String[] args) {
		new Thread(new TimeWaiting(), "TimeWaitingThread").start();
		new Thread(new Waiting(), "WaitingThread").start();
		
		new Thread(new Blocked(), "BThread-1").start();
		new Thread(new Blocked(), "BThread-2").start();
		new Thread(new Sync(), "SyncThread-1").start();
		new Thread(new Sync(), "SyncThread-2").start();
	}
	
	// 该线程不断进入睡眠
	// 超时等待
	static class TimeWaiting implements Runnable{

		// @Override
		public void run() {
			while(true) {
				try {
					TimeUnit.SECONDS.sleep(100);
					System.out.println("I am TimeWaiting Thread: " + Thread.currentThread().getName());
				}catch(InterruptedException e){}
			}		
		}
		
	}
	
	
	// 该线程在Waiting.class实例上等待
	// 等待
	static class Waiting implements Runnable{

		// @Override
		public void run() {
			
			while(true) {
				synchronized (Waiting.class) {
					try {
						System.out.println("I am Waiting Thread: " + Thread.currentThread().getName());
						Waiting.class.wait();
					}catch(InterruptedException e){
						e.printStackTrace();
					}
				}		
			}		
		}	
	}
	
	// 该线程在Blocked.class实例上加锁后，不会释放该锁
	// 阻塞
	static class Blocked implements Runnable{

		// @Override
		public void run() {
			synchronized (Blocked.class) {
				while(true) {
					try {
						System.out.println("I am Blocked Thread: " + Thread.currentThread().getName());
						TimeUnit.SECONDS.sleep(100);
					}catch(InterruptedException e){}
				}	
			}
		}
		
	}
	
	// 该线程用于同步锁
	// 同步
	static class Sync implements Runnable{

		// @Override
		public void run() {
			lock.lock();
			try {
				System.out.println("I am Sync Thread: " + Thread.currentThread().getName());
				TimeUnit.SECONDS.sleep(100);
			}catch(InterruptedException e) { }
			finally {
				lock.unlock();
			}
			
		}
		
	}
}

结果为：

I am Waiting Thread: WaitingThread
I  am Blocked Thread: BThread-1
I  am Sync Thread: SyncThread-1
I  am Blocked Thread: BThread-1
I  am TimeWaiting Thread: TimeWaitingThread
I  am Sync Thread: SyncThread-2
I  am Blocked Thread: BThread-1
I  am TimeWaiting Thread: TimeWaitingThread

Java知识点——线程的状态

线程的状态

相关推荐