多线程——

一、为什么要有多线程？

1、线程与进程

2、多线程的应用场景

3、小结编辑

二、多线程中的两个概念（并发和并行）

1、并发

2、并行

3、小结

三、多线程的三种实现方式

1、继承Thread类的方式进行实现

2、实现Runnable接口的方式进行实现

3、利用Callable接口和Future接口方式的实现

4、多线程三种实现方式对比

四、常见的成员方法

1、get/setName方法 -- 线程名字

2、currentThread方法 -- 获取当前线程对象

3、sleep方法 -- 线程休眠

4、set/getPriority方法 -- 线程优先级

5、setDaemon方法 -- 守护线程

6、yield方法 -- 礼让线程

7、join方法 -- 插入线程

8、线程的生命周期

五、线程安全的问题

1、练习：设计一个程序模拟电影院卖票

2、买票引发的安全问题

2.1、重复票的由来：（线程在执行代码的过程中，CPU的执行权随时有可能被抢走）

2.2、出现了超出范围的票：（和上面的原因相同）

3、安全问题的解决办法 -- 同步代码块

4、同步代码块中的两个小细节

4.1、细节1：synchronized要写在循环的里面编辑

4.2、细节2：synchronized中的锁对象一定是唯一的

5、同步方法

6、StringBuilder和StringBuffer的区别

7、Lock锁（手动加锁、释放锁）编辑

7.1、Lock使用不规范造成的两个安全问题

六、死锁

七、生产者和消费者（等待唤醒机制）

1、消费者等待

2、生产者等待编辑

3、常见方法（wait/notify/notifyAll）

4、消费者与生产者代码实现

4.1、Cook.java

4.2、Desk.java

4.3、Foodie.java

4.4、ThreadDemo.java

5、阻塞队列方式（另一种等待唤醒机制）编辑

5.1、阻塞队列的继承结构编辑

5.2、阻塞队列实现等待唤醒机制

7、多线程的6中状态

八、综合练习

1、多线程练习1（卖电影票）编辑

2、多线程练习2（送礼品）

3、多线程练习3（打印奇数数字）编辑

4、多线程练习4（抢红包）

5、多线程练习5（抽奖箱抽奖）

6、多线程练习6（多线程统计并求最大值）

7、多线程练习7（多线程之间的比较）

8、多线程练习8（多线程阶段大作业）

九、线程池

1、吃饭买碗的故事

1.1、问题编辑

1.2、解决方案

2、以前写多线程的弊端编辑

3、线程池的核心原理

4、线程池的代码实现

4.1、Executors工具类编辑

4.2、线程复用示例

4.3、创建一个有上限的线程池

5、自定义线程池（ThreadPoolExecutor）

5.1、任务拒绝策略编辑

5.2、代码实现编辑

5.3、小结编辑

6、最大并行数

6.1、什么是最大并行数？编辑

6.2、向Java虚拟机返回可用处理器的数目

7、线程池多大才合适？

编辑

十、多线程的额外扩展内容准备面试时可以再突击学习，资料可见《多线程（额外扩展）.md》

一、为什么要有多线程？

1、线程与进程

进程：进程是程序的基本执行实体

举例：在任务管理器中，一个软件运行之后，它就是一个进程

线程：（简单理解，线程就说应用软件中互相独立，可以同时运行的功能）

单线程程序：所有的都在一个线程中执行，耗时长

2、多线程的应用场景

3、小结

二、多线程中的两个概念（并发和并行）

1、并发

2、并行

以2核4线程为例：（如果计算机中只要4条线程，那么它是不用切换的，但如果线程越来越多，那么这个红线就会在多个线程之间随机的进行切换）

3、小结

三、多线程的三种实现方式

1、继承Thread类的方式进行实现

自己定义一个类继承Thread并重写run方法

创建子类的对象，并启动线程

2、实现Runnable接口的方式进行实现

自己定义一个类实现Runnable接口，并重新里面的run方法

public class MyRun implements Runnable {@Overridepublic void run() {//书写线程要执行的代码for (int i = 0; i < 100; i++) {//获取当前线程的对象/*Thread t = Thread.currentThread();System.out.println(t.getName()+"HelloWorld");*/System.out.println(Thread.currentThread().getName()+"HelloWorld");}}
}

package com.yaqi.a02threadcase2;public class ThreadDemo {public static void main(String[] args) {/*多线程的第二种启动方式：*   1.自己定义一个类实现Runnable接口*   2.重写里面的run方法*   3.创建自己的类的对象*   4.创建一个Thread类的对象，并开启线程*///创建MyRun的对象//表示多线程要执行的任务MyRun mr = new MyRun();//创建线程对象Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);//给线程设置名字t1.setName("线程1");t1.setName("线程2");//开启线程t1.start();t2.start();}
}

结果

3、利用Callable接口和Future接口方式的实现

package com.yaqi.a03threadcase3;import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class ThreadDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {/**   多线程的第三种实现方式：*       特点：可以获取到多线程运行的结果**       1. 创建一个类MyCallable实现Callable接口*       2. 重写call （是有返回值的，表示多线程运行的结果）**       3. 创建MyCallable的对象（表示多线程要执行的任务）*       4. 创建FutureTask的对象（作用管理多线程运行的结果）*       5. 创建Thread类的对象，并启动（表示线程）* *///创建MyCallable的对象（表示多线程要执行的任务）MyCallable mc = new MyCallable();//创建FutureTask的对象（作用管理多线程运行的结果）FutureTask<Integer> ft = new FutureTask<>(mc);//创建线程的对象Thread t1 = new Thread(ft);//启动线程t1.start();//获取多线程运行的结果Integer result = ft.get();System.out.println(result);}
}

package com.yaqi.a03threadcase3;import java.util.concurrent.Callable;public class MyCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {//求1~100之间的和int sum = 0;for (int i = 1; i <= 100; i++) {sum = sum + i;}return sum;}
}

4、多线程三种实现方式对比

四、常见的成员方法

1、get/setName方法 -- 线程名字

默认名字的由来：

序号自增

/*String getName()                    返回此线程的名称void setName(String name)           设置线程的名字（构造方法也可以设置名字）细节：1、如果我们没有给线程设置名字，线程也是有默认的名字的格式：Thread-X（X序号，从0开始的）2、如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置*/
//1.创建线程的对象MyThread t1 = new MyThread("飞机");MyThread t2 = new MyThread("坦克");//2.开启线程t1.start();t2.start();

MyThread

package com.yaqi.a04threadmethod1;public class MyThread extends Thread{public MyThread() {}public MyThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i < 100; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + "@" + i);}}
}

2、currentThread方法 -- 获取当前线程对象

static Thread currentThread()       获取当前线程的对象
细节：当JVM虚拟机启动之后，会自动的启动多条线程其中有一条线程就叫做main线程他的作用就是去调用main方法，并执行里面的代码在以前，我们写的所有的代码，其实都是运行在main线程当中

//哪条线程执行到这个方法，此时获取的就是哪条线程的对象Thread t = Thread.currentThread();String name = t.getName();System.out.println(name);//main

3、sleep方法 -- 线程休眠

static void sleep(long time)        让线程休眠指定的时间，单位为毫秒
细节：1、哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间2、方法的参数：就表示睡眠的时间，单位毫秒1 秒= 1000毫秒3、当时间到了之后，线程会自动的醒来，继续执行下面的其他代码

System.out.println("11111111111");Thread.sleep(5000);System.out.println("22222222222");

4、set/getPriority方法 -- 线程优先级

没有设置，优先级则默认为5，优先级越高，抢到CPU的概率就越高

最小1
最大10
默认5

5、setDaemon方法 -- 守护线程

两个线程执行的代码不同：守护线程是陆续结束的，所以守护线程也叫做备胎线程

应用场景

6、yield方法 -- 礼让线程

但是只是尽可能的均匀，不是绝对的

7、join方法 -- 插入线程

插入线程：将土豆插入到main线程之前，只有当土豆线程执行完毕，才会轮到main线程

8、线程的生命周期

五、线程安全的问题

1、练习：设计一个程序模拟电影院卖票

出现了超出票范围或者重复票的情况：

2、买票引发的安全问题

相同的票出现多次

出现了超出范围的票

2.1、重复票的由来：（线程在执行代码的过程中，CPU的执行权随时有可能被抢走）

2.2、出现了超出范围的票：（和上面的原因相同）

3、安全问题的解决办法 -- 同步代码块

示例代码

结果

4、同步代码块中的两个小细节

4.1、细节1：synchronized要写在循环的里面

4.2、细节2：synchronized中的锁对象一定是唯一的

5、同步方法

示例代码

将同步代码块改成同步方法：

6、StringBuilder和StringBuffer的区别

两个类的方法都是相同的

但是StringBuffer是线程安全的，它里面所有的方法都是线程同步的

StringBulider：代码单线程的不需要考虑多线程当中数据安全的情况
StringBuffer：多线程环境下需要考虑数据安全则选择StringBuffer

7、Lock锁（手动加锁、释放锁）

7.1、Lock使用不规范造成的两个安全问题

Ⅰ、重复票以及超出范围票

我们在使用Thread类实现多线程时，创建自己的类，一定要注意锁对象需要唯一，即在相关变量前加上static关键字

Ⅱ、程序无法正常终止

这是由于当满足条件时，循环直接被终止，导致lock锁没有被释放

Ⅲ、正确代码（标准写法）

即将容易产生异常的代码块放入try…catch中

六、死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

注意事项：千万不要让两个锁嵌套起来！

七、生产者和消费者（等待唤醒机制）

生产者消费者模式是一个十分经典的多线程协作的模式

1、消费者等待

2、生产者等待

3、常见方法（wait/notify/notifyAll）

4、消费者与生产者代码实现

4.1、Cook.java

public class Cook extends Thread{@Overridepublic void run() {/** 1. 循环* 2. 同步代码块* 3. 判断共享数据是否到了末尾（到了末尾）* 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）* */while (true){synchronized (com.yaqi.a13waitandnotify.Desk.lock){if(com.yaqi.a13waitandnotify.Desk.count == 0){break;}else{//判断桌子上是否有食物if(com.yaqi.a13waitandnotify.Desk.foodFlag == 1){//如果有，就等待try {com.yaqi.a13waitandnotify.Desk.lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}else{//如果没有，就制作食物System.out.println("厨师做了一碗面条");//修改桌子上的食物状态com.yaqi.a13waitandnotify.Desk.foodFlag = 1;//叫醒等待的消费者开吃com.yaqi.a13waitandnotify.Desk.lock.notifyAll();}}}}}
}

4.2、Desk.java

package com.yaqi.a13waitandnotify;public class Desk {/** 作用：控制生产者和消费者的执行** *///是否有面条  0：没有面条  1：有面条public static int foodFlag = 0;//总个数public static int count = 10;//锁对象public static Object lock = new Object();}

4.3、Foodie.java


public class Foodie extends Thread{@Overridepublic void run() {/** 1. 循环* 2. 同步代码块* 3. 判断共享数据是否到了末尾（到了末尾）* 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）* */while(true){synchronized (com.yaqi.a13waitandnotify.Desk.lock){if(com.yaqi.a13waitandnotify.Desk.count == 0){break;}else{//先判断桌子上是否有面条if(com.yaqi.a13waitandnotify.Desk.foodFlag == 0){//如果没有，就等待try {com.yaqi.a13waitandnotify.Desk.lock.wait();//让当前线程跟锁进行绑定} catch (InterruptedException e) {e.printStackTrace();}}else{//把吃的总数-1com.yaqi.a13waitandnotify.Desk.count--;//如果有，就开吃System.out.println("吃货在吃面条，还能再吃" + com.yaqi.a13waitandnotify.Desk.count + "碗！！！");//吃完之后，唤醒厨师继续做com.yaqi.a13waitandnotify.Desk.lock.notifyAll();//修改桌子的状态com.yaqi.a13waitandnotify.Desk.foodFlag = 0;}}}}}
}

4.4、ThreadDemo.java

package com.yaqi.a13waitandnotify;public class ThreadDemo {public static void main(String[] args) {/***    需求：完成生产者和消费者（等待唤醒机制）的代码*         实现线程轮流交替执行的效果** *///创建线程的对象Cook c = new Cook();Foodie f = new Foodie();//给线程设置名字c.setName("厨师");f.setName("吃货");//开启线程c.start();f.start();}
}

5、阻塞队列方式（另一种等待唤醒机制）

5.1、阻塞队列的继承结构

5.2、阻塞队列实现等待唤醒机制

Cook.java

package com.yaqi.a14waitandnotify;import java.util.concurrent.ArrayBlockingQueue;public class Cook extends Thread{ArrayBlockingQueue<String> queue;public Cook(ArrayBlockingQueue<String> queue) {this.queue = queue;}@Overridepublic void run() {while(true){//不断的把面条放到阻塞队列当中try {queue.put("面条");System.out.println("厨师放了一碗面条");} catch (InterruptedException e) {e.printStackTrace();}}}
}

put方法的源码中实现了Lock锁

Foodie.java：

take方法的底层也是有锁的


import java.util.concurrent.ArrayBlockingQueue;public class Foodie extends Thread{ArrayBlockingQueue<String> queue;public Foodie(ArrayBlockingQueue<String> queue) {this.queue = queue;}@Overridepublic void run() {while(true){//不断从阻塞队列中获取面条try {String food = queue.take();System.out.println(food);} catch (InterruptedException e) {e.printStackTrace();}}}
}

ThreadDemo.java：

package com.yaqi.a14waitandnotify;import java.util.concurrent.ArrayBlockingQueue;public class ThreadDemo {public static void main(String[] args) {/***    需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码*    细节：*           生产者和消费者必须使用同一个阻塞队列** *///1.创建阻塞队列的对象ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);//2.创建线程的对象，并把阻塞队列传递过去Cook c = new Cook(queue);Foodie f = new Foodie(queue);//3.开启线程c.start();f.start();}
}

打印语句是在锁的外面的，但是不会对数据造成影响，只是影响了控制台的打印阅读体验

7、多线程的6中状态

八、综合练习

1、多线程练习1（卖电影票）

2、多线程练习2（送礼品）

3、多线程练习3（打印奇数数字）

4、多线程练习4（抢红包）

package com.yaqi.test4case1;import java.util.Random;public class MyThread extends Thread{//共享数据//100块，分成了3个包static double money = 100;static int count = 3;//最小的中奖金额static final double MIN = 0.01;@Overridepublic void run() {//同步代码块synchronized (MyThread.class){if(count == 0){//判断，共享数据是否到了末尾（已经到末尾）System.out.println(getName() + "没有抢到红包！");}else{//判断，共享数据是否到了末尾（没有到末尾）//定义一个变量，表示中奖的金额double prize = 0;if(count == 1){//表示此时是最后一个红包//就无需随机，剩余所有的钱都是中奖金额prize = money;}else{//表示第一次，第二次（随机）Random r = new Random();//100 元   3个包//第一个红包：99.98//100 - (3-1) * 0.01double bounds = money - (count - 1) * MIN;prize = r.nextDouble(bounds);if(prize < MIN){prize = MIN;}}//从money当中，去掉当前中奖的金额money = money - prize;//红包的个数-1count--;//本次红包的信息进行打印System.out.println(getName() + "抢到了" + prize + "元");}}}
}

测试类：

package com.yaqi.test4case1;public class Test {public static void main(String[] args) {/*微信中的抢红包也用到了多线程。假设：100块，分成了3个包，现在有5个人去抢。其中，红包是共享数据。5个人是5条线程。打印结果如下：XXX抢到了XXX元XXX抢到了XXX元XXX抢到了XXX元XXX没抢到XXX没抢到*///创建线程的对象MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();MyThread t4 = new MyThread();MyThread t5 = new MyThread();//给线程设置名字t1.setName("小A");t2.setName("小QQ");t3.setName("小哈哈");t4.setName("小诗诗");t5.setName("小丹丹");//启动线程t1.start();t2.start();t3.start();t4.start();t5.start();}
}

精确运算：（BigDecimal）

package com.yaqi.test4case2;import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Random;public class MyThread extends Thread{//总金额static BigDecimal money = BigDecimal.valueOf(100.0);//个数static int count = 3;//最小抽奖金额static final BigDecimal MIN = BigDecimal.valueOf(0.01);@Overridepublic void run() {synchronized (MyThread.class){if(count == 0){System.out.println(getName() + "没有抢到红包！");}else{//中奖金额BigDecimal prize;if(count == 1){prize = money;}else{//获取抽奖范围double bounds = money.subtract(BigDecimal.valueOf(count-1).multiply(MIN)).doubleValue();Random r = new Random();//抽奖金额prize = BigDecimal.valueOf(r.nextDouble(bounds));}//设置抽中红包，小数点保留两位，四舍五入prize = prize.setScale(2,RoundingMode.HALF_UP);//在总金额中去掉对应的钱money = money.subtract(prize);//红包少了一个count--;//输出红包信息System.out.println(getName() + "抽中了" + prize + "元");}}}
}

5、多线程练习5（抽奖箱抽奖）

package com.yaqi.test5;import java.util.ArrayList;
import java.util.Collections;public class MyThread extends Thread {ArrayList<Integer> list;public MyThread(ArrayList<Integer> list) {this.list = list;}@Overridepublic void run() {//1.循环//2.同步代码块//3.判断//4.判断while (true) {synchronized (MyThread.class) {if (list.size() == 0) {break;} else {//继续抽奖Collections.shuffle(list);int prize = list.remove(0);System.out.println(getName() + "又产生了一个" + prize + "元大奖");}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}

测试类

import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:每次抽出一个奖项就打印一个(随机)抽奖箱1 又产生了一个 10 元大奖抽奖箱1 又产生了一个 100 元大奖抽奖箱1 又产生了一个 200 元大奖抽奖箱1 又产生了一个 800 元大奖抽奖箱2 又产生了一个 700 元大奖.....*///创建奖池ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建线程MyThread t1 = new MyThread(list);MyThread t2 = new MyThread(list);//设置名字t1.setName("抽奖箱1");t2.setName("抽奖箱2");//启动线程t1.start();t2.start();}
}

6、多线程练习6（多线程统计并求最大值）

示例代码一：（在练习5的基础上进行修改）

package com.yaqi.test6case1;import java.util.ArrayList;
import java.util.Collections;public class MyThread extends Thread {ArrayList<Integer> list;public MyThread(ArrayList<Integer> list) {this.list = list;}//线程一static ArrayList<Integer> list1 = new ArrayList<>();//线程二static ArrayList<Integer> list2 = new ArrayList<>();@Overridepublic void run() {while (true) {synchronized (MyThread.class) {if (list.size() == 0) {if("抽奖箱1".equals(getName())){System.out.println("抽奖箱1" + list1);}else {System.out.println("抽奖箱2" + list2);}break;} else {//继续抽奖Collections.shuffle(list);int prize = list.remove(0);if("抽奖箱1".equals(getName())){list1.add(prize);}else {list2.add(prize);}}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}

示例代码二：升级版--线程栈（示例一可以用，但不好）

改进后，这里只需要一个ArrayList就搞定了

package com.yaqi.test6case2;import java.util.ArrayList;
import java.util.Collections;public class MyThread extends Thread {ArrayList<Integer> list;public MyThread(ArrayList<Integer> list) {this.list = list;}@Overridepublic void run() {ArrayList<Integer> boxList = new ArrayList<>();//1 //2while (true) {synchronized (MyThread.class) {if (list.size() == 0) {System.out.println(getName() + boxList);break;} else {//继续抽奖Collections.shuffle(list);int prize = list.remove(0);boxList.add(prize);}}try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}

测试类

package com.yaqi.test6case2;import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，抽奖箱2总共产生了6个奖项。分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元*///创建奖池ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建线程MyThread t1 = new MyThread(list);MyThread t2 = new MyThread(list);//设置名字t1.setName("抽奖箱1");t2.setName("抽奖箱2");//启动线程t1.start();t2.start();}
}

示例二内存图讲解：

每个线程都有自己独立的空间

7、多线程练习7（多线程之间的比较）

示例代码：（难点在于如何获取两个线程中的最大值★）

调用多线程的第三种方式Callable来实现（可以返回结果）

MyCallable.java：

package com.yaqi.test7;import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.Callable;public class MyCallable implements Callable<Integer> {ArrayList<Integer> list;public MyCallable(ArrayList<Integer> list) {this.list = list;}@Overridepublic Integer call() throws Exception {ArrayList<Integer> boxList = new ArrayList<>();//1 //2while (true) {synchronized (MyCallable.class) {if (list.size() == 0) {System.out.println(Thread.currentThread().getName() + boxList);break;} else {//继续抽奖Collections.shuffle(list);int prize = list.remove(0);boxList.add(prize);}}Thread.sleep(10);}//把集合中的最大值返回if(boxList.size() == 0){return null;}else{return Collections.max(boxList);}}
}

package com.yaqi.test7;import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Test {public static void main(String[] args) throws ExecutionException, InterruptedException {/*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为    "抽奖箱1", "抽奖箱2"随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）以上打印效果只是数据模拟,实际代码运行的效果会有差异*///创建奖池ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);//创建多线程要运行的参数对象MyCallable mc = new MyCallable(list);//创建多线程运行结果的管理者对象//线程一FutureTask<Integer> ft1 = new FutureTask<>(mc);//线程二FutureTask<Integer> ft2 = new FutureTask<>(mc);//创建线程对象Thread t1 = new Thread(ft1);Thread t2 = new Thread(ft2);//设置名字t1.setName("抽奖箱1");t2.setName("抽奖箱2");//开启线程t1.start();t2.start();Integer max1 = ft1.get();Integer max2 = ft2.get();System.out.println(max1);System.out.println(max2);//在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元if(max1 == null){System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");}else if(max2 == null){System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");}else if(max1 > max2){System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");}else if(max1 < max2){System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");}else{System.out.println("两者的最大奖项是一样的");}}
}

8、多线程练习8（多线程阶段大作业）

九、线程池

1、吃饭买碗的故事

1.1、问题

1.2、解决方案

买个碗柜，买了碗之后不摔，存入碗柜中

2、以前写多线程的弊端

3、线程池的核心原理

当有新的任务出现，且线程池线程不足时，会新建线程以满足需求，其中最大线程的数量可以自行设置

4、线程池的代码实现

4.1、Executors工具类

示例代码：

MyRunnable.java:

package com.yaqi.a01threadpool1;public class MyRunnable implements Runnable{@Overridepublic void run() {for (int i = 1; i <= 100; i++) {System.out.println(Thread.currentThread().getName() + "---" + i);}}
}

测试类

package com.yaqi.a01threadpool1;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class MyThreadPoolDemo {public static void main(String[] args) throws InterruptedException {/*public static ExecutorService newCachedThreadPool()             创建一个没有上限的线程池public static ExecutorService newFixedThreadPool (int nThreads) 创建有上限的线程池*///1.获取线程池对象ExecutorService pool1 = Executors.newFixedThreadPool(3);//2.提交任务pool1.submit(new MyRunnable());pool1.submit(new MyRunnable());pool1.submit(new MyRunnable());pool1.submit(new MyRunnable());pool1.submit(new MyRunnable());pool1.submit(new MyRunnable());//3.销毁线程池//pool1.shutdown();}
}

4.2、线程复用示例

package com.yaqi.a02threadpool2;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo1 {public static void main(String[] args){/*ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);参数一：核心线程数量              不能小于0参数二：最大线程数                不能小于0，最大数量 >= 核心线程数量参数三：空闲线程最大存活时间       不能小于0参数四：时间单位                  用TimeUnit指定参数五：任务队列                  不能为null参数六：创建线程工厂              不能为null参数七：任务的拒绝策略             不能为null*/ThreadPoolExecutor pool = new ThreadPoolExecutor(3,  //核心线程数量，能小于06,  //最大线程数，不能小于0，最大数量 >= 核心线程数量60,//空闲线程最大存活时间TimeUnit.SECONDS,//时间单位new ArrayBlockingQueue<>(3),//任务队列Executors.defaultThreadFactory(),//创建线程工厂new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略);}
}

4.3、创建一个有上限的线程池

5、自定义线程池（ThreadPoolExecutor）

5.1、任务拒绝策略

以下面示例为例，它会将任务4抛弃，将任务10加入

5.2、代码实现

package com.yaqi.a02threadpool2;import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class MyThreadPoolDemo1 {public static void main(String[] args){/*ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);参数一：核心线程数量              不能小于0参数二：最大线程数                不能小于0，最大数量 >= 核心线程数量参数三：空闲线程最大存活时间       不能小于0参数四：时间单位                  用TimeUnit指定参数五：任务队列                  不能为null参数六：创建线程工厂              不能为null参数七：任务的拒绝策略             不能为null*/ThreadPoolExecutor pool = new ThreadPoolExecutor(3,  //核心线程数量，能小于06,  //最大线程数，不能小于0，最大数量 >= 核心线程数量60,//空闲线程最大存活时间TimeUnit.SECONDS,//时间单位new ArrayBlockingQueue<>(3),//任务队列Executors.defaultThreadFactory(),//创建线程工厂new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略);}
}