线程状态与线程池-CSDN博客

线程状态

线程之间的通信

线程状态

NEW：至今尚未启动的线程处于这种状态。
RUNNABLE：正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED：受阻塞并等待某个监视器锁的线程处于这种状态。
WAITING：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
TERMINATED：已退出的线程处于这种状态

等待唤醒案例

01 分析：
- 创建一个顾客线程(消费者)：告知老板要买包子的种类和数量，调用wait()方法，放弃CPU的执行，进入到WAITING状态(无限等待)
- 创建一个老板线程(生产者)：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子
02 注意：
- 顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在进行
- 同步使用的锁对象必须保证唯一
- 只有锁对象能够调用wait和notify方法
03 java.lang.Object中常用方法
- void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待
- void notify() 唤醒在此对象监视器上等待的单个线程 ,会继续执行wait方法之后的代码
- void notifyAll() 唤醒在此对象监视器上等待的所有线程
- 进入TimeWaiting(计时等待)有两种方式
  01 使用sleep(long m)方法：在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
  02 使用wait(long m)方法：wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
04 代码实现

public class demo01_wait_notify {
	public static void main(String[] args) {
		//创建锁对象，保证唯一
		Object obj = new Object();
		//创建一个顾客线程(消费者)
		new Thread() {
			@Override
			public void run() {
				//一直等着买包子
				while(true) {
					//保证等待和唤醒的线程只有一个，使用同步技术
					synchronized (obj) {
						System.out.println("告知老板要的包子的种类和数量");
						//没有办法抛出异常，因为父类的run方法也没有抛出异常，使用try...catch
						try {
							obj.wait();  //进入等待
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						//唤醒之后执行的代码
						System.out.println("顾客开吃");
						System.out.println("------------------------------");
					}
				}
			}
		}.start();
		//创建老板线程
		new Thread() {
			@Override
			public void run() {
				//一直做包子
				while(true) {
					try {
						Thread.sleep(5000);//花5s做包子
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//唤醒
					synchronized (obj) {
						System.out.println("老板5s后做好包子，告知顾客可以吃包子了");
						obj.notify();
					}
				}
			}
		}.start();
	}
}

等待唤醒机制

概念：多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同
案例分析：
资源类：包子类
生产者(包子铺)：是一个线程类，继承Thread类，生产包子
消费者(吃货)：是一个线程类，继承Thread类，吃包子

代码实现

/*
 	资源类：包子类
 	设置包子的属性
 		皮
 		陷
 		包子的状态：有true，没有false
 */
public class BaoZi {
	String pi;
	String xian;
	boolean flag = false; //一开始没有包子
}

//生产者
/*
 	包子铺：
 		设置线程任务run():生产包子
 		对包子的状态进行判断：
 			true:有包子，调用wait进入等待状态
 			false:没有包子 --- 生产包子 --- 修改包子状态为true --- 唤醒吃货线程
 			
 	注意：
 		包子铺线程和吃包子线程关系 ---> 通信(互斥)
 		同时同步技术保证两个线程只能有一个在执行
 		锁对象必须保证唯一，可以使用包子对象作为锁对象
 		包子铺类和吃货类需要把包子对象作为参数传递进来
 			1 需要在成员位置创建一个包子变量
 			2 使用带参数的构造方法，为这个包子变量赋值
 */
public class BaoZiPu extends Thread{
	//1 需要在成员位置创建一个包子变量
	private BaoZi bz;

	//使用带参构造方法，为这个包子变量赋值
	public BaoZiPu(BaoZi bz) {
		this.bz = bz;
	}
	//设置线程任务：生成包子
	@Override
	public void run() {
		int count = 0; //设置一个变量来控制包子
		//一直生产 包子
		while(true) {  
			synchronized (bz) {  //包子对象作为锁对象
				if(bz.flag == true) {
					//有包子，调用wait进入等待状态
					try {
						bz.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//被唤醒后执行，包子铺生产包子
				//交替生产两种包子
				if(count%2==0) {  //生成薄皮三鲜馅包子
					bz.pi = "薄皮";
					bz.xian = "三鲜馅";
				}else {
					bz.pi = "冰皮";
					bz.xian = "牛肉大葱馅";
				}
				count ++;
				System.out.println("包子铺正在生产："+bz.pi+bz.xian+"的包子");
				//生产包子需要3秒钟
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				//包子铺生产好包子，修改包子的状态为有true
				bz.flag = true;
				//唤醒吃货线程,让吃货线程吃包子
				System.out.println("包子铺已经生产好了"+bz.pi+bz.xian+"的包子，吃货可以开始吃了");
				bz.notify();
			}
		}
	}
}

//消费者
/*
 	吃货：
 		设置线程任务run():吃包子
 		对包子的状态进行判断：
 			true:有包子 --- 吃包子 --- 修改包子状态为false --- 唤醒包子铺线程
 			false:没有包子 --- 调用wait进入等待状态
 */
public class ChiHuo extends Thread{
	
	private BaoZi bz;  //设置包子变量
	
	public ChiHuo(BaoZi bz) {
		super();
		this.bz = bz;
	}

	//设置线程对象 --- 吃包子
	@Override
	public void run() {
		while(true) {
			synchronized (bz) {
				//对包子状态进行判断
				if(bz.flag == false) {  //没有包子，等待
					try {
						bz.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//线程唤醒之后执行的代码 --- 吃包子
				System.out.println("吃货正在吃:"+bz.pi+bz.xian+"的包子");
				bz.flag = false;
				//唤醒包子铺线程
				bz.notify();
				System.out.println("吃货已经把"+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
				System.out.println("-------------------------------S");
			}
		}
	}
}

//测试类
public class demo03_test {
	public static void main(String[] args) {
		//创建包子对象
		BaoZi bz = new BaoZi();
		//创建包子铺线程，生产包子
		new BaoZiPu(bz).start();
		//吃货线程，吃包子
		new ChiHuo(bz).start();
	}
}

线程池

问题：如果并发的线程数量很多，并且每一个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁地创建线程和销毁线程需要时间。
线程池：可以使线程得到复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务。

线程池的概念
其实就是一个容纳多个线程的容器，其中的线程可以被反复使用，省去了频繁的创建线程对象的操作，无需反复创建线程而消耗过多资源
在JDK1.5之后，JDK内置了线程池，我们可以直接使用。
线程池的使用

java.util.concurrent.Executors：线程池的工厂类，用来生产线程池
- static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
- 参数：
  - int nThreads:创建线程池中包含的线程数量
- 返回值：
  - ExecutorService接口
  - 返回的是ExecutorService接口的实现类对象，我们可以用ExecutorService接口接收(面向接口编程)

java.util.concurrent.ExecutorService:线程池接口
-用来从线程池中获取线程，调用start方法，执行线程任务
- submit(Runnable task)
  提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future
- 关闭/销毁线程池的方法
  void shutdown()
线程池的使用步骤：
1 使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2 创建一个类，实现Runnable接口，重写run方法，设置线程任务
3 调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程，执行run方法
4 调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

代码实现

//2 创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable{
	//设置线程任务
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
	}
}

//main
public class demo04_ThreadPool {
	public static void main(String[] args) {
		//1 获取线程池
		ExecutorService es = Executors.newFixedThreadPool(2);  //里面有2个线程
		//3 调用ExecutorService中的方法，传递线程任务(实现类)，开启线程，执行run方法
		es.submit(new RunnableImpl());  //pool-1-thread-1创建了一个新的线程执行
		//线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
		es.submit(new RunnableImpl());  //pool-1-thread-1创建了一个新的线程执行
		es.submit(new RunnableImpl());  //pool-1-thread-2创建了一个新的线程执行
		
		//4 调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
		es.shutdown();
//		es.submit(new RunnableImpl());   抛异常，线程池已销毁，不能获取线程了
	}
}