线程的生命周期

我们可以从java的Thread.State中发现线程有六种状态。分别是：

NEW：至今尚未启动的线程状态

RUNNABLE：可运行的线程的线程状态，包括正在运行的线程和就绪的线程。

BLOCKED：受阻塞并且正在等待监视器锁的某一线程的线程状态。

WAITING：某一等待线程的线程状态。

TIMED_WAITING：具有指定等待时间的某一线程的线程状态。

TERMINATED：以终止的线程的线程状态。线程已经结束执行。

下面我们分别用程序验证一下执行那些操作会处于其中某种状态。

public class Thread_A {
	public static void main(String[] args) {
		
		State s = new Thread(new Runnable(){
			@Override
			public void run() {
				System.out.println("线程A");				
			}			
		}).getState();
		System.out.println(s);//NEW
		
	}
}

我们可以发现刚创建的还没有调用start方法的线程处于NEW状态。

public class Thread_A {	
	static class B extends Thread{
		@Override
		public void run(){
			try{
				Thread.currentThread().sleep(20000);
			}catch(Exception e){				
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		B b = new B();
		b.start();
		Thread.currentThread().sleep(1000);
		System.out.println(b.getState()); //TIMED_WAITING		
	}
}

调用sleep（long times）会是线程处于TIMED_WAITING状态。

public class Thread_A {	
	static class B extends Thread{
		@Override
		public void run(){
			try{				
			     Thread.currentThread().join();//调用join（）,未设置等待时间		
			}catch(Exception e){				
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		B b = new B();
		b.start();
		Thread.currentThread().sleep(1000);
		System.out.println(b.getState()); // WAITING	
	}
}

我们在当前线程中，调用它自己的join（）方法，会使当前线程永远无法结束，所以会使线程当前线程（这里为b）的状态处于WAITING（无限期等待）状态。

public class Thread_A {	
	static synchronized void fun() throws InterruptedException{
		Thread.currentThread().sleep(100000);
		
	}
	static class B extends Thread{
		@Override
		public void run(){
			try{
				fun();
			}catch(Exception e){				
			}
		}
	}
	static class C extends Thread{
		@Override
		public void run(){
			try{
				fun();
			}catch(Exception e){				
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		
		B b = new B();
		C c = new C();
		b.start();
		c.start();
		Thread.currentThread().sleep(100);
		System.out.println(c.getState());//BLOCKED	
		
	}
}

可以看到，多个线程竞争同一把锁，没竞争到的线程将陷入，线程等待IO资源的时候也会处于BLOCKED状态。

public class Thread_A {	
	static class B extends Thread{
		@Override
		public void run(){
			synchronized (this) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}				
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {		
		B b = new B();
		b.start();
		Thread.sleep(100);
		System.out.println(b.getState());//WAITING
		
	}
}

从输出结果可以看出，调用wait（）方法会使线程处于WAITING状态。

public class Thread_A {	
	static class B extends Thread{
		@Override
		public void run(){
			synchronized (this) {
				try {
					this.wait(1000);
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		
		B b = new B();
		b.start();
		Thread.sleep(100);
		System.out.println(b.getState());//WAITING
		
	}
}

从输出结果可以看出，调用wait（long times）方法会使线程处于TIMED_WAITING状态。

线程运行结束就处于TERMINATED状态。

综上所述：

NEW：线程刚创建，还没调用start（）方法。

RUNNABLE：线程此时可能正在运行或者处于就绪队列

WAITING：调用join（）和wait（）会使线程处于此状态。

TIMED_WAITING：调用sleep（long times）、join（long times）、wait（long times）会处于此状态

BLOCKED：访问同步代码块被阻塞会处于此状态，线程等待某种资源也会处于此状态。

TERMIDATED：线程运行结束，处于此状态。