多线程 线程的状态

　　 线程对象在不同的运行时期有不同的状态，状态信息就存储在State枚举类中。

　　new ： 至今未启动的线程的状态
　　runnable： 虚拟机中正在运行的状态。
　　blocked:受阻塞并等待某个监视器的线程处于这种状态。
　　waiting：无限期的等待另一个线程来执行某一特定操作的线程处于此种状态。
　　timed waiting：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
　　terminated：已退出的线程处于这种状态，
　　下面让我们来对此进行验证。

　　废话不多说，撸代码。

　　1 线程

public class MyThread extends Thread{
    
    public MyThread(){
        System.out.println("构造方法中的状态  : "+Thread.currentThread().getState());
    }
    
    public void run(){
        System.out.println("run方法中的状态    ："+Thread.currentThread().getState());
    }
}

public class Method {
	
	private String lock;
	
	public Method(String lock){
		this.lock=lock;
	}
	
	public void methodA() throws InterruptedException{
		synchronized (lock) {
			lock.wait();
		}
	}
}

　　主线程代码

public class Run {

	public static void main(String[] args) throws InterruptedException {
		/**
		 * new runnable terminated状态验证
		 */
		MyThread thread=new MyThread();
		System.out.println("main 方法中的状态1："+thread.getState());
		Thread.sleep(1000);
		thread.start();
		Thread.sleep(1000);
		System.out.println("main 方法中的状态2："+thread.getState());

		Thread t=new Thread(new Runnable() {
			public void run() {
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"A");
		t.start();
		Thread.sleep(200);
		System.out.println("sleep状态是 ："+t.getState());;
		Thread.sleep(200);
		
		String lock="0";
		Thread t2=new Thread(new Runnable() {
			public void run() {
				Method method=new Method(lock);
				try {
					method.methodA();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		t2.start();
		Thread.sleep(200);
		System.out.println("wait 的状态是:"+t2.getState());
		
		
	}

}

　　运行主线程，控制台输出

构造方法中的状态  : RUNNABLE
main 方法中的状态1：NEW
run方法中的状态    ：RUNNABLE
main 方法中的状态2：TERMINATED
sleep状态是 ：TIMED_WAITING
wait 的状态是:WAITING

　因为最后验证的wait，所以此线程并不会终止，因为没写唤醒方法。

接下来验证阻塞的线程的状态

public class Method {
	
	private String lock;
	public Method (String lock){
		this.lock=lock;
	}
	
	public void methodA() throws InterruptedException{
		synchronized (lock) {
			Thread.sleep(2000);
		}
	}
}

　　

public class Run {

	public static void main(String[] args) throws InterruptedException {
		String lock="0";
		Method method=new Method(lock);
		
		Thread t1=new Thread(new Runnable() {
			public void run() {
				try {
					method.methodA();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			public void run() {
				try {
					method.methodA();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		t1.start();
		Thread.sleep(200);
		t2.start();
		System.out.println("blocked的状态："+t2.getState());

	}

}

　　控制台输出

blocked的状态：BLOCKED

　　Java线程在启动之后，有的状态与状态之间是能切换的，如runnable和waiting状态，但是有的是不能切换的，如 terminated状态的就不能自动进入running状态。

　　　　每一个优秀的人，都有一段沉默的时光。不抱怨，不诉苦。最后度过那些感动自己的日子。