java多线程-基础篇

在J2EE开发中很多地方都会用到线程，这样不仅可以提高执行效率，而且还可以提高资源的利用率

线程基础

线程的状态：

• NEW 线程刚创建，尚未启动
• RUNNABLE 线程正在运行中，在这种状态下不会发生wait、sleep的等待状态
• BLOCKED 在多个线程有同步操作的场景
• WAITING 线程拥有了某个锁之后，调用了他的wait方法
• TIMEDWAITING 有时间限制的WAITING _
• TERMINATED 线程已经运行完，基本等于死了

NEW状态：

直接创建一个线程然后获取状态

public class ThreadDemo {
	public static void main(String[] args) {
		Thread t = new Thread();
		System.out.println(t.getState());
	}
}

执行结果：NEW

RUNNABLE 状态：

线程执行后获取状态

public class RunnableThread {
	public static void main(String[] args) {
		Thread t = new Thread() {
			@Override
			public void run() {
				for(int i = 0; i < Integer.MAX_VALUE; i++){
					System.out.println(i);
				}
			}
		};
		
		t.start();
		System.out.println(t.getState());
	}
}

执行结果：RUNNABLE

BLOCKED状态：

多个线程相互等待synchronized时，线程会出现BLOCKED状态；

public class BlockedThread {
	
	public static void main(String[] args) {
		final Object lock = new Object();
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < Integer.MIN_VALUE; i++) {
					synchronized (lock) {
						System.out.println(i);
					}
				}
				
			}
		};
		Thread t1 = new Thread(r);
		t1.setName("t1");
		Thread t2 = new Thread(r);
		t2.setName("t2");
		t1.start();
		t2.start();
	}
}

这个时候一个线程RUNNABLE，另一个就是BLOCKED

WAITING 状态：

这个需要用到生产者消费者模型, 当生产者生产过慢的时候, 消费者就会等待生产者的下一次notify;

public class WaitingThread {
	public static void main(String[] args) {
		final Object lock = new Object();
		Thread t1 = new Thread() {
			@Override
			public void run() {
				int i = 0;
				while(true) {
					synchronized (lock) {
						try {
							lock.wait();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
                      	System.out.println(i++);
					}
				}
			}
		};
		
		Thread t2 = new Thread() {
			@Override
			public void run() {
				while(true) {
					for (int i = 0; i < Integer.MAX_VALUE; i++) {
						System.out.println(i);
					}
					lock.notifyAll();
				}
			}
		};
		
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
	}
}

TIMED_WAITING状态：

在上个例子的基础上wait加上时间参数就OK了；

synchronized (lock) {
    try {
    	lock.wait(60*1000L);
    } catch (InterruptedException e) {
    	e.printStackTrace();
    }
    System.out.println(i++);
}

t1现在为TIMED_WAITING (on object monitor)这里括号里还可能是sleeping等其它情况。

TERMINATED状态 ：

线程运行结束就是TERMINATED状态

private static void TERMINATED() {
  	Thread t1 = new Thread();
  	t1.start();
  	System. out.println(t1.getState());
  	try {
   		 Thread. sleep(1000L);
  	} catch (InterruptedException e) {
  	}
  	System. out.println(t1.getState());
}

执行结果：

​ RUNNABLE

​ TERMINATED