阅读量:0
一、基本概念
1.什么是线程？
线程就是，操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。简单理解就是：应用软件中互相独立，可以同时运行的功能
2.什么是多线程？
有了多线程，我们就可以让程序同时做多件事情
3.多线程的作用？
提高效率
4.线程的应用场景？
只要你想让多个事情同时运行就需要用到多线程
比如：软件中的耗时操作、所有的聊天软件、所有的服务器
二、并发和并行的概念
1.什么是并发？
并发就是，同一时刻，有多个指令在单个CPU上交替执行。
2.什么是并行？
并行就是，同一时刻，有多个指令在多个CPU上同时执行
3.电脑不是只有一个CPU么，这个多个CPU同时执行的并行究竟是什么？
其实，CPU在市面有很多类型如下
比如2核4线程的CPU，就可以同时运行4个线程的任务。
三、多线程的实现方式（3种）
1.继承Thread类的方式进行实现
用法：
1.定义一个类继承Thread类
2.这个类重写run方法
3.在main方法里面创建定义的类的对象
4.通过该对象的.start()方法启动线程
示例代码
public class ThreadDemo1 { public static void main(String[] args) { MyThread myThread1 = new MyThread(); MyThread myThread2 = new MyThread(); myThread1.setName("线程1"); myThread2.setName("线程2"); myThread1.start(); myThread2.start(); } } class MyThread extends Thread{ @Override public void run(){ for(int i=0;i<100;i++){ System.out.println(Thread.currentThread().getName()+" "+i); } } }上面的两个线程的代码run方法是同时执行的，并不会等一个线程的循环走完。
注意：线程类开启后执行的是run方法的代码
2.实现Runnable接口的方式进行实现
用法：
1.自己定义一个类实现Runnable接口
2.重写里面的run方法
3.在main方法创建自己的类的对象
4.将定义的类传递给Thread构造方法创建一个Thread类的对象，并开启线程
示例
public class ThreadDemo2 { public static void main(String[] args) { MyThread myThread = new MyThread(); Thread thread1 = new Thread(myThread); Thread thread2 = new Thread(myThread); thread1.setName("线程1"); thread2.setName("线程2"); thread2.start(); thread1.start(); } } class MyThread implements Runnable{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }
3.利用Callable接口和Future接口方式实现
前面两种实现方式，run方法没有返回值，不知道线程实现的结果，现在这个第三种方法是有返回值的。
用法：
1.创建一个类MyCallable实现callable接口
2.重写call（是有返回值的，表示多线程运行的结果）
3.创建MyCallable的对象（表示多线程要执行的任务）
4.传递MyCallable对象为参数创建FutureTask的对象（作用管理多线程运行的结果）
5.传递FutureTask对象为参数创建Thread类的对象，并启动（表示线程）
示例
public class ThreadDemo3 { public static void main(String[] args) throws ExecutionException, InterruptedException { MyCallable mc = new MyCallable(); FutureTask<Integer> ft = new FutureTask<>(mc); Thread t = new Thread(ft); t.start(); System.out.println(ft.get()); } } class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { int sum = 0; for (int i = 0; i <= 100; i++) { sum += i; } return sum; } }结果输出5050
4.三种方式的比较
四、Thread类的常用成员方法
1.七个方法
2.前四个细节
String getName()
void setName(String name)
细节：
1. 果我们没有给线程设置名字，线程也是有默认的名字的
格式：Thread-X（X序号，从0开始的）
2.如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置
static Thread currentThread()
细节：
当JVM虚拟机启动之后，会自动的启动多条线程
其中有一条线程就叫做main线程
他的作用就是去调用main方法，并执行里面的代码
在以前，我们写的所有的代码，其实都是运行在main线程当中
static void sleep(long time)
细节：
1.哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间
2.方法的参数：就表示睡眠的时间，单位毫秒
1秒 = 1000毫秒
3.时间到了之后，线程会自动的醒来，继续执行下面的其他代码
3.线程的优先级
（1）线程调度
抢占式调度：各条线程执行的顺序和时间是不确定的（随机）
非抢占式调度：各条线程执行的顺序是轮流执行和执行时间是差不多的
java中是选取第一种抢占式调度
（2）优先级（1~10）
抢占式调度就要涉及到线程的优先级越大，执行的顺序越前
于是可以通过Thread类的上面的两个成员方法来设置和获取线程的优先级
没有设置默认就是5
注意：这里的优先级是指优先级大的线程先执行的概率比较大，而不是百分百，比如说有两个一样的方法的线程，优先大的线程是有概率计较大的先执行完，但还是有小概率执行慢
4.守护线程
当一个线程使用Thread类的etDaemon(boolean on)时，这个线程变成守护线程。
细节：
这个线程也可以叫做“备胎”线程，它将其他线程视为“女神”线程，当其他线程结束的时候，这个守护线程就会陆续结束，觉得自己没必要存在了，这就会可能导致守护线程的代码没有全部执行完。
应用场景
上面聊天的场景，两个人聊天开两个线程，一个聊天，一个传输文件，如果聊天线程关闭了，就没有传输文件的必要了，于是将传输文件的线程设置为守护线程。
5.出让/礼让线程
在当前线程的工作不重要时，将CPU资源让位给其他线程，通过使用Thread类的
yield()方法来将当前资源让位给其他同优先级线程public static void main(String[] args) { Thread t1 = new Thread(() -> { System.out.println("线程1开始运行！"); for (int i = 0; i < 50; i++) { if(i % 5 == 0) { System.out.println("让位！"); Thread.yield(); } System.out.println("1打印："+i); } System.out.println("线程1结束！"); }); Thread t2 = new Thread(() -> { System.out.println("线程2开始运行！"); for (int i = 0; i < 50; i++) { System.out.println("2打印："+i); } }); t1.start(); t2.start(); }观察结果，我们发现，在让位之后，尽可能多的在执行线程2的内容。
6.插入线程
当我们希望一个线程等待另一个线程执行完成后再继续进行，我们可以使用Thread类的
join()方法来实现线程的插入。public static void main(String[] args) { Thread t1 = new Thread(() -> { System.out.println("线程1开始运行！"); for (int i = 0; i < 50; i++) { System.out.println("1打印："+i); } System.out.println("线程1结束！"); }); Thread t2 = new Thread(() -> { System.out.println("线程2开始运行！"); for (int i = 0; i < 50; i++) { System.out.println("2打印："+i); if(i == 10){ try { System.out.println("线程1加入到此线程！"); t1.join(); //在i==10时，让线程1加入，先完成线程1的内容，再继续当前内容 } catch (InterruptedException e) { e.printStackTrace(); } } } }); t1.start(); t2.start(); }线程2执行一半，线程1加入，先完成线程1的内容，再继续线程2的内容
五、线程的生命周期
六、线程的安全问题
1.售票代码引出问题
有100张票售卖，一共3个窗口在卖。
下面代码设置三个线程当作三个卖票的窗口，看看有什么问题
public class ThreadSafetyProblem { public static void main(String[] args) { MyThread1 myThread1 = new MyThread1(); MyThread1 myThread2 = new MyThread1(); MyThread1 myThread3 = new MyThread1(); myThread1.setName("窗口1"); myThread2.setName("窗口2"); myThread3.setName("窗口3"); myThread1.start(); myThread2.start(); myThread3.start(); } } class MyThread1 extends Thread{ //静态变量，几个线程共享 private static int count = 0; public void run(){ while(true){ try {//这里只能try-catch丢给JVM，不能throws Thread.sleep(100); //因为父类的run方法没有throws } catch (InterruptedException e) { throw new RuntimeException(e); } if (count < 100){ System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票"); }else{ break; } } } }
2.超卖和重复卖问题
运行后出现的问题结果如下图：
三个窗口在同时卖一张票，不合法！
超卖了，仅有100张票
原因
线程的执行是有随机性的，cpu的执行权有可能被其他线程抢走。
线程1执行完票数的自增还没来得及打印的时候，线程2和线程3完成自增就会导致超卖和重复卖
那么要怎么解决这个安全问题呢？下一个点就会讲到解决的方法之一——同步代码块。
七、同步代码块
同步代码块的意思就是，把操作共享数据的代码锁起来
1.格式
synchronized(锁){
操作共享数据的代码
}
特点：
1.锁默认打开，有一个线程进去了，锁自动关闭
2.里面的代码全部执行完毕，线程出来，锁自动打开
2.修改后的售票代码
class MyThread1 extends Thread{ //静态变量，几个线程共享 private static int count = 0; //锁对象，一定要是唯一的 static Object obj = new Object(); public void run(){ while(true){ //同步代码块 synchronized (obj){ try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } if (count < 2000){ System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票"); }else { break; } } } } }运行后的结果，票正常售卖，从第一张卖到最后一张。
3.细节问题
细节1：同步代码块不能放在while循环里面，因为放在外的话，一个线程拿到锁后就会必须把循环执行完，才会释放锁，这样的话一个线程就把票都卖完了。
细节2：锁的对象必须是唯一的，修改后的代码的锁是一个Object对象，用static修饰后表示全局共享唯一的对象。也可以使用MyThread.class表示唯一的字节码文件对象
八、同步方法
如果我们要锁的代码是整个方法，这个时候就要用到同步方法了
就是把synchronized关键字加到方法上
1.格式
修饰符 synchronized 返回值类型 方法名（方法参数）{….}
2.特点
特点1：同步方法是锁住方法里面所有的代码
特点2：锁对象不能自己指定，如果方法是非静态的，锁对象就是方法所在类对象this
如果方法是静态的，锁对象就是当前类的字节码文件对象
3.使用同步方法解决售票问题
示例代码
这段代码与前面不同的是，这段代码是使用实现Runnable接口实现的多线程，只需要创建一个实现Runnable接口的javabean类的对象，所以票数这个变量的内存地址是唯一的，所以不用像上面的代码一样用static修饰票数count
注意：下面同步方法是非静态的，所以锁对象就是MyRunnable类的对象mr
public class ThreadSafetyProblem { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); Thread myThread1 = new Thread(mr); Thread myThread2 = new Thread(mr); Thread myThread3 = new Thread(mr); myThread1.setName("窗口1"); myThread2.setName("窗口2"); myThread3.setName("窗口3"); myThread1.start(); myThread2.start(); myThread3.start(); } } class MyRunnable implements Runnable{ int count = 0; public void run(){ while(true){ //同步代码块 if (method()) break; } } //锁对象是this private synchronized boolean method() { try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } if (count < 2000){ System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票"); }else { return true; } return false; } } 4.StringBuffer为什么是线程安全的？
虽然StringBuilder和StringBuffer的成员方法是一样的，但为什么之前建议在多线程的情况下使用StringBuffer？
这是由于StringBuffer的成员方法比较 StringBuilder多了一个Sychronized修饰词，保证了线程的安全，但是在单线程的情况下，还是使用StringBuilder好一些。
九、Lock锁
1.售票代码使用手动上锁
public class ThreadSafetyProblem { public static void main(String[] args) { MyThread1 myThread1 = new MyThread1(); MyThread1 myThread2 = new MyThread1(); MyThread1 myThread3 = new MyThread1(); myThread1.setName("窗口1"); myThread2.setName("窗口2"); myThread3.setName("窗口3"); myThread1.start(); myThread2.start(); myThread3.start(); } } class MyThread1 extends Thread{ //静态变量，几个线程共享 private static int count = 0; //创建一个锁对象 用static修饰表示共享唯一 Lock lock = new ReentrantLock(); public void run(){ while(true){ lock.lock(); try { Thread.sleep(10); if (count < 2000){ System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票"); }else { break; } } catch (InterruptedException e) { throw new RuntimeException(e); } finally { lock.unlock(); } } } }十、死锁
1.示例代码
下面的代码用了锁的嵌套
public class MyThread extends Thread { static Object objA = new Object(); static Object objB = new Object(); @Override public void run() { //1.循环 while (true) { if ("线程1".equals(getName())) { synchronized (objA) { System.out.println("线程1拿到了A锁，准备拿B锁");//线程1卡在这里 synchronized (objB) { System.out.println("线程1拿到了B锁，顺利执行完一轮"); } } } else if ("线程2".equals(getName())) { if ("线程2".equals(getName())) { synchronized (objB) { System.out.println("线程2拿到了B锁，准备拿A锁");//线程2卡在这里 synchronized (objA) { System.out.println("线程2拿到了A锁，顺利执行完一轮"); } } } } } } }运行结果
显然两个线程都卡在第一层同步代码的锁那里，程序结束不了。
2.如何解决
很简单，不要写锁或同步代码块的锁嵌套就行。
十一、生产者和消费者模式
生产者消费者模式是一个十分经典的多线程协作的模式，就是要打破两个线程随机执行的规则，你一次我一次。
1.流程框图（等待唤醒机制）
2.涉及的方法
调用
wait()方法的线程会释放它持有的锁，并进入等待状态，直到它被其他线程通过调用notify()或notifyAll()唤醒。
3.步骤
消费者和生产者的代码都按下面的步骤走：
1.循环
2.同步代码块(给消费者或生产者上锁)
3.判断共享数据是否到了末尾（到了末尾）
4.判断共享数据是否到了末尾（没有到末尾，执行（消费者或生产者的）核心逻辑）
4. 示例代码
(1)桌子代码
public class Desk { /* 桌子的作用：控制生产者和消费者的执行 */ // 判断桌子上有没有食物 // 0 没有食物 生产者的线程执行 // 1 有食物 消费者的线程执行 //这里一般不用boolean类型，因为boolean类型只能是true或者false //如果有多条线程，int 可以表示多条线程的状态 public static int foodFlat = 0; // 消费者现在所能吃食物的碗数 public static int count = 10; //锁对象 static Object lock = new Object(); }(2)消费者代码
public class Foodie extends Thread { /* 1.循环 2.同步代码块(给消费者或生产者上锁) 3.判断共享数据是否到了末尾（到了末尾） 4.判断共享数据是否到了末尾（没有到末尾，执行（消费者或生产者的）核心逻辑） */ public void run(){ while(true){ synchronized (Desk.lock){ if (Desk.count == 0){//吃不下了，直接结束 break; }else { //如果桌上没有食物 if (Desk.foodFlat == 0){ try { //进入等待 Desk.lock.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } }else { //桌上有食物 Desk.foodFlat = 0; Desk.count--; System.out.println("消费者吃掉了一碗面条，还能吃"+Desk.count+"碗"); //通知唤醒厨师 Desk.lock.notify(); } } } } } }(3)生产者代码
public class Cook extends Thread { public void run(){ while(true){ synchronized (Desk.lock){ //判断消费者是否吃饱了 if (Desk.count==0){ //吃饱了就结束 break; }else { //消费者还能吃 //判断桌子上还有食物么 //有食物就进入等待 if (Desk.foodFlat==1){ try { Desk.lock.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } }else { //没食物 //厨师做一碗面条 Desk.foodFlat = 1; System.out.println("厨师做了一碗面条"); //做好就唤醒消费者 Desk.lock.notify(); } } } } } }(4)main方法
public class Test { public static void main(String[] args) { Desk desk = new Desk(); Foodie foodie = new Foodie(); Cook cook = new Cook(); foodie.setName("吃货"); cook.setName("厨师"); foodie.start(); cook.start(); } }(5)执行结果
从运行结果可以看出来，消费者和生产者模式可以使多个线程不再随机而是按顺序的来执行。
5.阻塞队列实现唤醒机制
(1)成员方法put和take
put方法底层原理
放入一个数据，put方法接收数据，先使当前线程获得锁（这个队列的），唤醒等待的线程，如果队列满了，当前线程进入等待，释放当前锁。
take方法底层原理
take方法取出数据，先使当前线程获得锁（这个队列的），唤醒等待的线程，如果队列空的，当前线程进入等待，释放当前锁。
(2)代码实现
用阻塞队列实现消费者和生产者的示例代码
消费者代码
public class Foodie extends Thread { ArrayBlockingQueue<String> queue; public Foodie(ArrayBlockingQueue<String> queue) { this.queue = queue; } public void run() { while(true){ try { queue.take(); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("吃货吃了一碗面条"); } } }
生产者代码
public class Cook extends Thread{ ArrayBlockingQueue<String> queue; public Cook(ArrayBlockingQueue<String> queue) { this.queue = queue; } public void run() { while(true){ try { queue.put("一碗面"); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("厨师做了一碗面条"); } } }
main方法
public class Test { public static void main(String[] args) { ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1); Foodie f = new Foodie(queue); Cook c = new Cook(queue); f.setName("吃货"); c.setName("厨师"); f.start(); c.start(); } }
运行结果
看到上面的结果有人会认为，厨师连续做了两碗面，是不是违反了模式了？
其实不然，消费者和生产者两条线程还是一条一次轮流执行的，重复输出是因为输出的代码放在了锁的外面，所以两个线程是随机的，抢着输出的，厨师做了多少碗面和消费者吃了多少碗的数量还是一样的。厨师放一碗面到队列，吃货就拿一碗。
注意：锁只在阻塞队列里面，即示例代码的put和take方法里面
十二、线程的6种状态
严格的来说，线程有7种状态，但是线程在进入要运行阶段的时候，JVM直接将线程丢给操作系统，java就不管了。所以对于java来说，线程是有6种状态。如下，
十三、Demo
1.Demo1
有100份礼品，两人同时发送，当剩下的礼品品小于10份分的时候则不再送出
利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来
public class MyRunnable implements Runnable{ int count = 100; @Override public void run() { while (true) { synchronized (this) { if (count < 10){ break; }else { count--; System.out.println(Thread.currentThread().getName() + "送出一份礼物，剩余" + count + "份礼物"); } } } } } public class Test { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); Thread t1 = new Thread(mr); Thread t2 = new Thread(mr); t1.setName("小明"); t2.setName("小红"); t1.start(); t2.start(); } }
2.Demo2
public class MyRunnable implements Runnable{ double money = 100; int count = 3; Random rnd = new Random(); public void run(){ synchronized (this) { if (count == 0){ System.out.println(Thread.currentThread().getName()+"没抢到"); }else if (count == 1){ count--; System.out.println(Thread.currentThread().getName()+"抢到了"+money+"元"); money = 0; } else { double get = (rnd.nextDouble()*money); System.out.println(Thread.currentThread().getName()+"抢到了"+get+"元"); money = money - get; count--; } } } } public class Test { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); Thread t1 = new Thread(mr); Thread t2 = new Thread(mr); Thread t3 = new Thread(mr); Thread t4 = new Thread(mr); Thread t5 = new Thread(mr); t1.setName("玩家1"); t2.setName("玩家2"); t3.setName("玩家3"); t4.setName("玩家4"); t5.setName("玩家5"); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); } }
3.Demo3
public class MyRunnable implements Runnable{ //奖池 ArrayList<Integer> list; public MyRunnable(ArrayList<Integer> list) { this.list = list; } @Override public void run() { while (true){ synchronized (this) { if (list.isEmpty()){ break; } Collections.shuffle(list); System.out.println(Thread.currentThread().getName()+"又产生了一个"+list.get(0)+"元大奖"); list.remove(0); } //在锁外面休眠一会，这样另外一个线程就先执行，输出会好看一点 try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700); MyRunnable mr = new MyRunnable(list); Thread t1 = new Thread(mr); Thread t2 = new Thread(mr); t1.setName("抽奖箱1"); t2.setName("抽奖箱2"); t1.start(); t2.start(); } }
4.Demo4 （多线程统计并求最大值）
public class MyRunnable implements Runnable{ //奖池 ArrayList<Integer> list; public MyRunnable(ArrayList<Integer> list) { this.list = list; } @Override public void run() { //定义一个集合，收集每一个抽奖箱每次中奖的金额 ArrayList<Integer> moneys = new ArrayList<>(); while (true){ synchronized (this) { if (list.isEmpty()){ Collections.sort(moneys); System.out.println("在此次抽奖过程中，"+Thread.currentThread().getName() +"总共产生了"+moneys.size()+"个奖项"); String string = moneys.toString(); System.out.println("\t分别为:"+string.substring(1,string.length()-1) +"最高奖项为"+moneys.get(moneys.size() - 1) +",总计额为"+moneys.stream().mapToInt(Integer::intValue).sum()); break; } Collections.shuffle(list); moneys.add(list.get(0)); list.remove(0); } try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700); String name1 = "抽奖箱1"; String name2 = "抽奖箱2"; MyRunnable mr = new MyRunnable(list); Thread t1 = new Thread(mr); Thread t2 = new Thread(mr); t1.setName(name1); t2.setName(name2); t1.start(); t2.start(); } }
5.Demo5（多线程之间的比较）
由于这里要多线程之间进行比较，所以必须要有返回值，run方法没有返回值，所以使用第三种方法实现多线程，即实现Callable接口和Future接口
public class MyCallable implements Callable<Integer> { //奖池 ArrayList<Integer> list; public MyCallable(ArrayList<Integer> list) { this.list = list; } @Override public Integer call(){ //定义一个集合，收集每一个抽奖箱每次中奖的金额 ArrayList<Integer> moneys = new ArrayList<>(); while (true){ synchronized (this) { if (list.isEmpty()){ Collections.sort(moneys); System.out.println("在此次抽奖过程中，"+Thread.currentThread().getName() +"总共产生了"+moneys.size()+"个奖项"); String string = moneys.toString(); System.out.println("\t分别为:"+string.substring(1,string.length()-1) +"最高奖项为"+moneys.get(moneys.size() - 1) +",总计额为"+moneys.stream().mapToInt(Integer::intValue).sum()); break; } Collections.shuffle(list); moneys.add(list.get(0)); list.remove(0); } try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } } return moneys.get(moneys.size() - 1); } } public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { ArrayList<Integer> list = new ArrayList<>(); Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700); String name1 = "抽奖箱1"; String name2 = "抽奖箱2"; MyCallable mc = new MyCallable(list); FutureTask<Integer> ft1 = new FutureTask<>(mc); FutureTask<Integer> ft2 = new FutureTask<>(mc); Thread t1 = new Thread(ft1,name1); Thread t2 = new Thread(ft2,name2); t1.start(); t2.start(); if (ft1.get()>ft2.get()){ System.out.println("在此次抽奖过程中,"+name1+"中产生了最大奖项，该奖项金额为"+ft1.get()+"元"); }else { System.out.println("在此次抽奖过程中,"+name2+"中产生了最大奖项，该奖项金额为"+ft2.get()+"元"); } } }
十四、多线程的内存图
十五、线程池
1.核心原理
（1）创建一个池子，池子中是空的
（2）提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子
下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
（3）但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待
2.操作步骤
（1）创建线程池对象
（2）提交任务(提交线程)
（3）任务都执行完毕后，关闭线程池
注意：一般的服务器线程池是不会关闭的，比如王者游戏24小时都能玩
3.自定义线程池
把一个餐厅的运营的七大核心因素看作线程的参数
(1)两种情况+三个临界点
A.线程池的参数如下，提交的任务数小于3+3+3，因此不会触发任务过多解决方案，8个任务从核心线程开始放，然后放队伍，发现不够放了，于是找来临时工（临时线程）放多余的两个任务。
注意：任务并不是先放就先执行，比如下面任务7，8后放比在排队的4，5，6先走。
B.下面这种情况和上面不同的是，提交的任务数量超过了3+3+3，于是最后一个任务触发了任务拒绝策略。 其他和上面相同
三个临界点
(2)任务拒绝策略
(3)创建一个线程池
构造方法和参数如下
使用这个线程池就提交任务就行pool.submit(线程任务)
(4)最大并行数
在多线程编程中，指同时运行的线程数量的上限。
下面代码可以获得java可用的处理器的数目，即可同时运行线程的最大数量
(5)线程池多大合适
cpu计算时间和等待时间可以通过插件thread dump计算统计
