四、线程的通信
可以理解为交替
wait()与notify()和notifyAll()
wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或ntifyll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll():唤醒正在排队等待资源的所有线程结束等待
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.langllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。
实例
package com.caq.java2; /** * @ClassName CommunicatrionTEst * @Description 线程通信的例子；使用两个线程打印1-100.线程1，线程2，交替打印 * * 涉及到的三个方法： * wait（）：一旦执行此方法，当前线程进入阻塞状态，并释放同步监视器 * notify（）：一旦执行此方法，就会唤醒一个wait的线程，如果有多个线程被wait有限释放优先级高的 * nitifyAll（）：一旦执行此方法，就会唤醒所有的wait的线程 * * 说明： * 1.wait， notify（），nitifyAll（）三个方法必须使用在同步代码块或同步方法中 * 2.wait， notify（），nitifyAll（）三个方法调用者必须是同步块或同步方法中的同步监视器 * 3.wait， notify（），nitifyAll（）三个方法都是java.lang.Object类中方法 * 否则会出现IllegalMonitorStateException异常 * * 面试题：sleep（）和wait（）方法的异同 * 相同点：一旦执行方法都会使线程进入阻塞状态 * 不同点：1）两方法声明的位置不一致，一个是Thread一个是Object * 2）调用的要求不一致，sleep（）方法可以在任何需要场景下调用，wait（）必须使用在同步代码块中或同步方法中 * 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep（）不会释放锁，wait（）会释放锁 * * @Author Jack * @Date 2021/11/23 22:52 * @Version 1.0 */ class Number implements Runnable{ private int number = 1; @Override public void run() { while (true){ synchronized (this) { notify();//当线程1wait后，释放锁。线程2进来调用notify唤醒线程1 if (number < 100){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":"+number); number++; try { //使得调用如下wait（）方法的线程进入阻塞状态 //进入wait状态会释放锁 wait(); } catch (InterruptedException e) { e.printStackTrace(); } }else { break; } } } } } public class CommunicationTest { public static void main(String[] args) { Number number = new Number(); Thread t1 = new Thread(number); Thread t2 = new Thread(number); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
生产者/消费者问题
package com.caq.java2; /** * @ClassName ProductTest * @Description 线程通信的应用:经典例题:生产者 消费者问题 * 生产者(Productor)将产品交给店员(Clerk),而消费者(Customer) 从店员处取走产品， * 店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员 * 会叫生产者停一下， 如果店中有空位放产品了再通知生产者继续生产:如果店中没有产品 * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 * <p> * 分析: * 1.是否是多线程问题? 是，生产者线程，消费者线程 * 2.是否有共享数据? 是，店员(或产品) * 3.如何解决线程的安全问题?同步机制，有三种方法 * 4.是否涉及线程的通信? 是 * @Author Jack * @Date 2021/11/23 23:21 * @Version 1.0 */ class Clerk { private int productCount = 0; //生产产品 public synchronized void produceProduct() { if (productCount < 20){ productCount++; System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品"); notify(); }else { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } //等待 } } //消费产品 public synchronized void consumeProduct() { if (productCount > 0){ System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品"); productCount--; notify(); }else { //等待 try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Producer extends Thread {//生产者 private Clerk clerk; public Producer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { System.out.println(getName() + "：开始生产产品..."); while (true) { try { sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } clerk.produceProduct(); } } } class Consumer extends Thread { private Clerk clerk; public Consumer(Clerk clerk) { this.clerk = clerk; } @Override public void run() { while (true) { try { sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } clerk.consumeProduct(); } } } public class ProductTest { public static void main(String[] args) { Clerk clerk = new Clerk(); Producer p1 = new Producer(clerk); Consumer c1 = new Consumer(clerk); Consumer c2 = new Consumer(clerk); p1.setName("生产者"); p1.start(); c1.setName("消费者1"); c2.setName("消费者2"); c1.start(); c2.start(); } }
五、JDK5.0新增线程创建方式
1.实现Callable接口
与使用Runnable相比，Callable功 能更强大些
相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助Future Task类，比如获取返回结果
Future接口
可以对具体Runnable、Callable任 务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
实例如下
package com.caq.java2; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * @ClassName ThreadNew * @Description 创建线程的第三种方式 * 实现Callable接口 --jdk5.0 * * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？ * 1.call（）可以有返回值 * 2.call（）可以抛出异常，被外面的操作捕获。获取异常的信息 * 3.Callable是支持反省的 * * * @Author Jack * @Date 2021/11/24 8:41 * @Version 1.0 */ //1.创建一个实现Callable的实现类 class NumThread implements Callable{ //2.实现call方法，将此线程需要执行的操作声明在call（）中 @Override public Object call() throws Exception { int sum = 0; for (int i = 0; i <=100; i++) { if (i %2 ==0){ // System.out.println(i); sum += i; } } return sum; } } public class ThreadNew { public static void main(String[] args) { //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); //4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start（） new Thread(futureTask).start(); try { //6.获取Callable中的call方法的返回值 //get（）返回值即为FutureTask构造器参数Callable实现重写的call（）的返回值 Object sum = futureTask.get(); System.out.println(sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
2.使用线程池
背景
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
优点
提高响应速度(减少了创建新线程的时间)
降低资源消耗(重复利用线程池中线程，不需要每次都创建)
便于线程管理
corePoolSize: 核心池的大小.
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
…
线程池相关API
JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command) :执行任务/命令，没有返回值，一 般用来执行Runnable
Future submit(Callable task): 执行任务，有返回值，一 般又来执行Callable
void shutdown() :关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool(): 创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor() :创建一个 只有一个线程的线程池
Executors.newScheduledThreadPool(n): 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
实例
package com.caq.java2; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * @ClassName ThreadPool * @Description 创建线程的方式四： * 使用线程池 * 好处: * 1.提高响应速度(减少了创建新线程的时间) * 2.降低资源消耗(重复利用线程池中线程，不需要每次都创建) * 3.便于线程管理 * corePoolSize:核心池的大小 * maximumPoolsize:最大线程数 * keepAliveTime:线程没有任务时最多保持多长时间后会终止 * * 创建多线程有几种方式？ * 四种！ * * @Author Jack * @Date 2021/11/24 9:13 * @Version 1.0 */ class NumberThread implements Runnable { @Override public void run() { for (int i = 0; i < 101; i++) { if (i % 2 == 0) { System.out.println(Thread.currentThread().getName()+":"+i); } } } } class NumberThread1 implements Runnable { @Override public void run() { for (int i = 0; i < 101; i++) { if (i % 2 != 0) { System.out.println(Thread.currentThread().getName()+":"+i); } } } } public class ThreadPool { public static void main(String[] args) { //Executors.newFixedThreadPool(n);创建一个可重用固定线程数的线程池 //1.提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //设置线程池的属性 System.out.println(service.getClass());//ThreadPoolExecutor /**提供参数的目的是为了告诉这个线程要干什么 NumberThread numberThread = new NumberThread(); service.execute(numberThread); 匿名类的实现方式 */ //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适用于Runnable service.execute(new NumberThread1()); // service.submit(Callable callable) 适合用于Callable //3.关闭线程池 service.shutdown(); } }
