笔记：Java之多线程

教程：https://www.bilibili.com/video/BV1V4411p7EF?t=13&p=6

笔记：Java之多线程

目录

• 笔记：Java之多线程
  • 1 线程实现
    • 1-1 继承Thread类
    • 1-2 实例一：图片下载
    • 1-3 实现Runnable接口
    • 1-4 实例二：购买火车票
    • 1-5 实例三：龟兔赛跑
    • 1-6 实现Callable接口
    • 1-7 Lambda表达式
    • 1-8 静态代理
  • 2 线程状态
    • 2-1 线程状态
    • 2-2 线程方法
    • 2-3 线程停止
    • 2-4 线程休眠——sleep
    • 2-5 线程礼让——yield
    • 2-6 线程强制执行——join
    • 2-7 观测线程状态
    • 2-8 线程优先级
    • 2-9 守护线程
  • 3 线程同步
    • 3-1 同步方法
    • 3-2 JUC包之安全类型
    • 3-3 死锁
    • 3-4 Lock锁
  • 4 线程通信
    • 4-1 生产者消费者问题
    • 4-2 解决方法一 --> 管程法
    • 4-3 解决方法二 --> 信号灯法
    • 4-4 线程池

1 线程实现

1-1 继承Thread类

1. 自定义线程类继承Thread类；

   // 创建线程方式一：继承Thread类，重写run()方法，调用start开启线程；
   // 线程开启不一定立即执行，由CPU调度执行；
   
   public class TestThread1 extends Thread
   {
   
   }
   

2. 重写run()方法，编写线程执行体；

   	// run()方法线程体
   	@Override
   	public void run()
   	{
   		for(int i = 0; i < 200; i++)
   		{
   			System.out.println("Run! Run! Run! ---- " + i);
   		}
   	}
   

3. 创建线程对象，调用start()方法启动线程；

   		// 创建一个线程对象
   		TestThread1 testThread1 = new TestThread1();
   		
   		// 调用start()方法开启线程
   		testThread1.start();
   

1-2 实例一：图片下载

• 继承Thread类；

  // 练习Thread，实现多线程同步下载图片；
  
  public class TestThread2 extends Thread
  {
  
  }
  

• 重写run()方法；

  	// 下载图片线程的执行体
  	@Override
  	public void run()
  	{
  		WebDownloader webDownloader = new WebDownloader();
  		webDownloader.downloader(url, name);
  		System.out.println("成功下载了文件名为：" + name + "的图片！");
  	}
  

• 创建线程对象，启动线程；

  		TestThread2 t1 = new TestThread2("https://w.wallhaven.cc/full/ym/wallhaven-ym1wp7.jpg", "1.jpg");
  		TestThread2 t2 = new TestThread2("https://w.wallhaven.cc/full/6k/wallhaven-6k8kkx.jpg", "2.jpg");
  		TestThread2 t3 = new TestThread2("https://w.wallhaven.cc/full/13/wallhaven-13vym3.jpg", "3.jpg");
  		
  		// 方法一：继承Thread类
  /*		t1.start();
  		t2.start();
  		t3.start();*/
  		// 方法二：实现Runnable接口
  		new Thread(t1).start();
  		new Thread(t2).start();
  		new Thread(t3).start();
  

• 图片下载器WebDownloader；

  // 下载器
  class WebDownloader
  {
  	// 下载方法
  	public void downloader(String url, String name)
  	{
  		try
  		{
  			FileUtils.copyURLToFile(new URL(url), new File(name));
  		}
  		catch (IOException e)
  		{
  			e.printStackTrace();
  			System.out.println("IO异常，downloader()方法出现问题。");
  		}
  	}
  }
  

• 图片下载结果；

1-3 实现Runnable接口

1. 定义MyRunnable类实现Runnable接口；

   // 创建线程方式二：实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start开启线程；
   
   public class TestThread3 implements Runnable
   {
   
   }
   

2. 重写run()方法，编写线程执行体；

   	// run()方法线程体
   	@Override
   	public void run()
   	{
   		for(int i = 0; i < 200; i++)
   		{
   			System.out.println("Run! Run! Run! ---- " + i);
   		}
   	}
   

3. 创建线程对象，调用start()方法启动线程；

   		// 创建Runnable接口的实现类对象
   		TestThread3 testThread3 = new TestThread3();
   		
   		// 创建线程对象，通过线程对象来开启我们的线程，代理
   		// Thread thread = new Thread(testThread3);
   		// 调用start()方法开启线程
   		// thread.start();
   		new Thread(testThread3).start();
   

1-4 实例二：购买火车票

• 实现Runnable接口；

  // 购买火车票：多个线程同时操作同一个对象；
  // 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱；
  
  public class TestThread4 implements Runnable
  {
  
  }
  

• 重写run()方法，模拟延时；

  	@Override
  	public void run(){
  		while (true){
  			if (ticketNums <= 0){
  				break;
  			}
  			
  			// 模拟延时
  			try{
  				Thread.sleep(200);
  			}
  			catch (InterruptedException e){
  				e.printStackTrace();
  			}
  			
  			System.out.println(Thread.currentThread().getName() + "-->拿到了第 " + ticketNums-- + " 张票。");
  		}
  	}
  

• 启动线程；

  		TestThread4 ticket = new TestThread4();
  		
  		new Thread(ticket, "张三").start();
  		new Thread(ticket, "李四").start();
  		new Thread(ticket, "王五").start();
  

• 最终购买结果；

  

1-5 实例三：龟兔赛跑

1. 设置赛道距离，离终点越来越近；

   			if (steps >= 100)
   			{
   
   			}
   

2. 判断比赛是否结束；

   			// 判断比赛是否结束
   			boolean flag = gameOver(i);
   			// 如果比赛结束，程序停止
   			if (flag)
   			{
   				break;
   			}
   

3. 打印出胜利者；

   				System.out.println("Winner is " + winner);
   

4. 比赛开始；

   		Race race = new Race();
   		
   		new Thread(race, "兔子").start();
   		new Thread(race, "乌龟").start();
   

5. 模拟兔子睡觉；

   			// 模拟兔子睡觉
   			if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0)
   			{
   				try
   				{
   					Thread.sleep(1);
   				}
   				catch (InterruptedException e)
   				{
   					e.printStackTrace();
   				}
   			}
   

6. 乌龟获胜；

   

继承Thread类	实现Runnable接口
子类继承Thread类具备多线程能力	实现接口Runnable具有多线程能力
启动线程：子类对象.start()	启动线程：传入目标对象+Thread对象.start()
不建议使用：避免OOP单继承局限性	推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

1-6 实现Callable接口

1. 实现Callab接口，需要返回值类型；

   // 创建线程方式三：实现Callable接口；
   // 优点：可以定义返回值，可以抛出异常；
   
   public class TestCallable implements Callable<Boolean>
   {
   	private String url;  // 网络图片地址
   	private String name; // 保存图片文件名
   	
   	public TestCallable(String url, String name)
   	{
   		this.url = url;
   		this.name = name;
   	}	
   }
   

2. 重写call()方法，需要抛出异常；

   	// 下载图片线程的执行体
   	@Override
   	public Boolean call()
   	{
   		WebDownloader webDownloader = new WebDownloader();
   		webDownloader.downloader(url, name);
   		System.out.println("成功下载了文件名为：" + name + "的图片！");
   		return true;
   	}
   

3. 创建目标对象；

   		TestCallable t1 = new TestCallable("https://w.wallhaven.cc/full/ym/wallhaven-ym1wp7.jpg", "1.jpg");
   		TestCallable t2 = new TestCallable("https://w.wallhaven.cc/full/6k/wallhaven-6k8kkx.jpg", "2.jpg");
   		TestCallable t3 = new TestCallable("https://w.wallhaven.cc/full/13/wallhaven-13vym3.jpg", "3.jpg");
   

4. 创建执行任务：ExecutorService ser = Executors.newFixedThreadPool(3);

   		// 创建执行服务
   		ExecutorService ser = Executors.newFixedThreadPool(3);
   

5. 提交执行：Future r1 = ser.submit(t1);

   		// 提交执行
   		Future<Boolean> r1 = ser.submit(t1);
   		Future<Boolean> r2 = ser.submit(t2);
   		Future<Boolean> r3 = ser.submit(t3);
           
           System.out.println(rs1);
   		System.out.println(rs2);
   		System.out.println(rs3);
   

6. 获取结果：boolean rs1 = r1.get();

   		// 获取结果
   		boolean rs1 = r1.get();
   		boolean rs2 = r2.get();
   		boolean rs3 = r3.get();
   

7. 关闭服务：ser.shutdownNow();

   		// 关闭服务
   		ser.shutdownNow();
   

1-7 Lambda表达式

• 可避免匿名内部类定义过多问题；

• 其是指属于函数式编程的概念；

• 函数式接口：

  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口；

    public interface Runnable
    {
    	public abstract Void run();
    }
    

  • 对于函数式接口，可以通过Lambda表达式来创建该接口的对象；

• Lambda表达式推导：

  • 定义一个函数接口；

    interface ILike
    {
    	void lambda();
    }
    
    

  • 实现类；

    class Like1 implements ILike
    {
    	@Override
    	public void lambda()
    	{
    		System.out.println("I like Lambda1!");
    	}
    }
    

  • 静态内部类；

    	static class Like2 implements ILike
    	{
    		@Override
    		public void lambda()
    		{
    			System.out.println("I like Lambda2!");
    		}
    	}
    

  • 局部内部类；

    		class Like3 implements ILike
    		{
    			@Override
    			public void lambda()
    			{
    				System.out.println("I like Lambda3!");
    			}
    		}
    		
    		like = new Like3();
    		like.lambda();
    

  • 匿名内部类，没有类的名称，必须借助接口或者父类；

    		like = new ILike()
    		{
    			@Override
    			public void lambda()
    			{
    				System.out.println("I like Lambda4!");
    			}
    		};
    		like.lambda();
    

  • 使用Lambda简化；

    		like = () ->
    		{
    			System.out.println("I like Lambda5!");
    		};
    		like.lambda();
    

• Lambda表达式的简化：

  • 一切的前提是接口为函数式接口；

  • 多个参数也可以去掉参数类型，但必须加小括号；

  • 只能在有一行代码的情况下才能去掉花括号，若有多行则必须使用代码块包裹；

    		// Lambda表达式
    		love = (int a) ->
    		{
    			System.out.println("I love you! --> " + a);
    		};
    		love.love(5);
    		
    		// 简化1：参数类型
    		love = (a) ->
    		{
    			System.out.println("I love you! --> " + a);
    		};
    		love.love(520);
    		
    		// 简化2：小括号
    		love = a ->
    		{
    			System.out.println("I love you! --> " + a);
    		};
    		love.love(521);
    		
    		// 简化3：花括号
    		love = a -> System.out.println("I love you! --> " + a);
    		love.love(5201314);
    

1-8 静态代理

• 静态代理模式：
  • 真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色；
  • 代理对象可以做很多真实对象做不了的事情，真实对象可以专注做自己的事情；

// 真实角色，你去结婚
class You implements Marry
{
   @Override
   public void HappyMarry()
   {
      System.out.println("婚礼现场，太好看了！");
   }
}

// 代理角色，帮你结婚
class WeddingCompany implements Marry
{
   //代理谁-->真实目标角色
   private Marry target;
   
   public WeddingCompany(Marry target)
   {
      // 真实对象
      this.target = target;
   }
   
   @Override
   public void HappyMarry()
   {
      this.target.HappyMarry();
   }
}

2 线程状态

2-1 线程状态

2-2 线程方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程体休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否出于活动状态

2-3 线程停止

• 不推荐使用stop()、destroy()，已废弃；

• 建议线程正常停止，利用次数，不建议死循环；

• 建议使用一个标志位进行终止变量，设置一个标志位，当flag=false，则终止线程运行；

  • 设置一个标志位；

    	private boolean flag = true;
    

  • 设置一个公开的方法停止线程，转换标志位；

    	public void stop()
    	{
    		this.flag = false;
    	}
    

  • 调用stop()方法切换标志位，让线程停止；

    				testStop.stop();
    				System.out.println("线程需要停止");
    

2-4 线程休眠——sleep

• sleep(时间)指定当前线程阻塞的毫秒数；
• sleep存在异常InterruptException；
• sleep时间到达后线程进入就绪状态；
• sleep可以模拟网络延时、倒计时等；
• 每一个对象都有一个锁，sleep不会释放锁；

			// 模拟网络延时，放大问题的发生性；			
			// 模拟延时
			try
			{
				Thread.sleep(2000);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}

	// 模拟倒计时
	public static void main(String[] args)
	{
		try
		{
			tenDown();
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		
		// 打印当前系统时间
		Date startTime = new Date(System.currentTimeMillis()); // 获取当前系统时间
		
		while (true)
		{
			try
			{
				Thread.sleep(1000);
				System.out.println(new SimpleDateFormat("HH:mm:ss:").format(startTime));
				startTime = new Date(System.currentTimeMillis()); // 更新当前时间
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}

2-5 线程礼让——yield

• 让当前正在执行的线程停止，但不阻塞；
• 将线程从运行状态转为就绪状态；
• 让CPU重新调度，但礼让不一定成功；

		MyYield myYield = new MyYield();
		
		new Thread(myYield,"A").start();
		new Thread(myYield,"B").start();
		new Thread(myYield,"C").start();
		new Thread(myYield,"D").start();
		new Thread(myYield,"E").start();
		new Thread(myYield,"F").start();
		new Thread(myYield,"G").start();
		
		System.out.println(Thread.currentThread().getName() + " is beginning...");
		Thread.yield(); // 礼让
		System.out.println(Thread.currentThread().getName() + " is ending...");

2-6 线程强制执行——join

• join合并线程，其他线程阻塞；
• 待此线程执行完毕后，再执行其他线程；

		// 启动线程
		TestJoin testJoin = new TestJoin();
		Thread thread = new Thread(testJoin);
		thread.start();
		
		// 主线程
		for (int i = 0; i <= 500; i++)
		{
			if (i == 200)
			{
				thread.join(); // 插队
			}
			System.out.println("main-->" + i);
		}

2-7 观测线程状态

• 线程状态Thread.State：
  • NEW：尚未启动的线程处于此状态；
  • RUNNABLE：在Java虚拟机中执行的线程处于此状态；
  • BLOCKED：被阻塞等待监视器锁定的线程处于此状态；
  • WAITING：正在等待另一个线程执行特定动作的线程处于此状态；
  • TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态；
  • TERMINATED：已退出的线程处于此状态；
• 观察状态；

		// 观察状态
		Thread.State state = thread.getState();
		System.out.println(state); // NEW

• 观察启动后；

		// 观察启动后
		thread.start(); // 启动线程
		state = thread.getState();
		System.out.println(state); // RUN
		
		while (state != Thread.State.TERMINATED)
		{
			// 只要线程不终止，就一直输出状态
			Thread.sleep(100);
			state = thread.getState(); // 更新线程状态
			System.out.println(state); // 输出状态
		}

2-8 线程优先级

• Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行；
• 线程优先级用数字表示，范围从1到10：
  • Thread.MIN_PRIORITY = 1;
  • Thread.NORM_PRIORITY = 5;
  • Thread.MAX_PRIORITY = 10;
• 使用以下方式来改变或或获取优先级：
  • getPriority();
  • setPriority(int xxx);
• 优先级的设定建议在start()调度前；
• 优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用了，都看CPU的调度；

		MyPriority myPriority = new MyPriority();
		
		Thread t1 = new Thread(myPriority);
		Thread t2 = new Thread(myPriority);
		Thread t3 = new Thread(myPriority);
		Thread t4 = new Thread(myPriority);
		
		// 设置优先级，再启动
		t1.start();
		
		t2.setPriority(1);
		t2.start();
		
		t3.setPriority(4);
		t3.start();
		
		t4.setPriority(Thread.MAX_PRIORITY); // MAX_PRIORITY
		t4.start();

2-9 守护线程

• 线程分为用户线程和守护线程；
• 虚拟机必须确保用户线程执行完毕；
• 虚拟机不用等待守护线程执行完毕；
• 如后台记录操作日志，监控内存，垃圾回收等待；

		Thread thread = new Thread(god);
		thread.setDaemon(true); // 默认是false表示是用户线程，正常的线程都是用户线程

		thread.start(); // 守护线程启动

		new Thread(human).start(); // 用户线程启动

3 线程同步

• 并发：处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象；
• 线程同步：一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列；
• 锁机制：当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可；

3-1 同步方法

• synchronized关键字；
• 同步方法：public synchronized void method(int args) {};
  • synchronized方法控制对对象的访问，每个对象对应一把锁；
  • 每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞；
  • 方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行；
  • 缺陷：若将一个大的方法申明位synchronized将会影响效率；
• 同步块：synchronized(Obj) {};
  • Obj被称为同步监视器，可以是任何对象，但推荐使用共享资源作为同步监视器；
  • 同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this；
  • 同步监视器的执行过程：
    • 第一个线程访问，锁定同步监视器，执行其中代码；
    • 第二个线程访问，发现同步监视器被锁定，无法访问；
    • 第一个线程访问完毕，解锁同步监视器；
    • 第二个线程访问，发现同步监视器没有锁，然后锁定并访问；

  // 票
  private int ticketNums = 10;
  boolean flag = true; // 外部停止方式

  // synchronized 同步方法，锁的是this
  private synchronized void buy(){

    // 判断是否有票
    if (ticketNums <= 0){
      flag = false;
      return;
    }
    // 买票
    System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
  }

3-2 JUC包之安全类型

    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
    for (int i = 0; i < 10000; i++) {
      new Thread(() -> {
        list.add(Thread.currentThread().getName());
      }).start();
    }

    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

3-3 死锁

• 两个或者多个线程都各自占有一些共享资源，都在等待对方释放资源而停止执行的情形；
• 某一个同步块同时拥有”两个以上对象的锁“时，就可能会发生”死锁“的问题；

  // 化妆，互相持有对方的锁，就是需要拿到对方的资源
    if (choice == 0){
      synchronized (lipstick){
        // 获得口红的锁
        System.out.println(this.girlName + "获得口红的锁");
        Thread.sleep(1000);
        synchronized (mirror){
        // 一秒钟后想获得镜子
        System.out.println(this.girlName + "获得镜子的锁");
        }
      }
    }
    else{
      synchronized (mirror){
        // 获得镜子的锁
        System.out.println(this.girlName + "获得镜子的锁");
        Thread.sleep(1000);
        synchronized (lipstick){
        // 一秒钟后想获得口红
        System.out.println(this.girlName + "获得口红的锁");
      }
    }

• 产生死锁的四个必要条件：
  • 互斥条件：一个资源每次只能被一个进程使用；
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
  • 不剥夺资源：进程已获得的资源，在未使用完之前，不能强行剥夺；
  • 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系；
• 我们只要能够破解其中任意一个或多个条件就可以避免死锁的发生；

3-4 Lock锁

• 通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当；
• 每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象；
• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义；
• 在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁；

  // 定义Lock锁
      try {
        lock.lock(); // 加锁
        if (ticketNums > 0){
          try {
            Thread.sleep(1000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(ticketNums--);
        }
        else{
          break;
        }
      }
      finally {
        lock.unlock(); // 解锁
      }
    }
  }
}

• synchronized与Lock的对比：
  • Lock是显式锁，手动开启和关闭锁，synchronized是隐式锁，出了作用域自动释放；
  • Lock只有代码块锁，synchronized有代码块锁和方法所；
  • 使用Lock锁，JVM将花费更少的时间来调度线程，性能更好，并且具有更好的拓展性（提供更多子类）；
  • 优先使用顺序：Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

4 线程通信

4-1 生产者消费者问题

• 生产者和消费者问题是一个多线程同步问题的经典案例：该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题；
• 生产者和消费者在同一时间段内共用同一个存储空间，生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程，与此同时，消费者也在缓冲区消耗这些数据，该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据；
• 要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。
• 通常采用进程间通信的方法解决该问题。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。

• Java提供了几个方法解决线程之间的通信问题；

方法名	作用
wait()	表示线程一直等待，知道其他线程通知，与sleep不同，会释放锁；
wait(long timeout)	指定等待的毫秒数；
notify()	唤醒一个处于等待状态的线程；
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度；

• 注意：均是Object类的方法，都只能在同步方法或同步代码块中使用，否则会抛出异常；

4-2 解决方法一 --> 管程法

• 生产者：

class Productor extends Thread{

  SynContainer container;

  public Productor(SynContainer container){
    this.container = container;
  }
}

• 消费者：

class Consumer extends Thread{

  SynContainer container;

  public Consumer(SynContainer container){
    this.container = container;
  }
}

• 缓冲区（以生产者为例）：

class SynContainer{
  // 生产者生产产品
  public synchronized void push(Chicken chicken){
    // 判断能否生产
    if (count == chickens.length){
      // 容器满，消费者开始消费，生产者等待
      try {
        this.wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    // 容器未满，生产者开始生产
    chickens[count] = chicken;
    count++;

    // 消费者继续消费
    this.notifyAll();
  }
}

4-3 解决方法二 --> 信号灯法

• 生产者：

// 生产者-->演员
class Player extends Thread{

  TV tv;
  public Player(TV tv){
    this.tv = tv;
  }
}

• 消费者：

// 消费者-->观众
class Audience extends Thread{

  TV tv;
  public Audience(TV tv){
    this.tv = tv;
  }
}

• 产品（以表演为例）：

// 产品-->节目
// 演员表演，观众等待
// 观众观看，演员等待

  // 表演
  public synchronized void play(String program){

    if (!flag){
      try {
        this.wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    
    // 通知观众观看
    this.notifyAll();
    this.program = program;
    this.flag = !this.flag;
  }

4-4 线程池

• 可提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中；
• 优点：
  • 提高响应速度，减少了创建新线程的时间；
  • 降底资源管理，重复利用线程池内线程，不需要次次新创建；
  • 便于线程管理：
    • corePoolSize：核心池的大小；
    • maximumPoolSize：最大线程数；
    • keepAliveTime：线程没有任务时最多保持多长时间后终止；

    // 1.创建服务，创建线程池
    // newFixedThreadPool()的参数为线程池大小
    ExecutorService service = Executors.newFixedThreadPool(10);

    service.execute(new MyThread());
    service.execute(new MyThread());
    service.execute(new MyThread());
    service.execute(new MyThread());

    // 2.关闭连接
    service.shutdown();