一、故事讲解
1.故事
有一家月饼店开业了,店里面有3个核心员工,这些人负责月饼的制作,3人同时工作制作100个月饼,每个人做完自己的月饼就会忙着下一个月饼的制作。因为总不可能要100个员工来做这些月饼吧,那也太浪费了。这些月饼的制作顺序是按照先后排队等待被制作的。
中秋佳节来临了,这些月饼的单子一下子赶了起来。忙不过来那就只能请一些临时员工来帮忙,但是核心员工忙得过来就用不上临时员工了。同时根据这些核心员工和临时员工的工作能力来判断接单情况,超过工作情况就不接单了,等先忙完这些再说。忙完这些月饼的制作,临时员工就会被辞退的。
2.怎么判断忙不过来,该找临时员工了?
3个核心线程都在忙,100个任务都排满了,那就只能找临时员工了
3.详解:
月饼店---线程池
3个核心员工--3个核心线程
100个月饼---100个任务
临时员工---临时线程
辞退---销毁临时线程(自动销毁,不用手动去设置)
二、概念讲解
1.什么是线程池?
答:一个可以复用线程的技术
2.如果不用线程池会怎么样?
答: 如果用户每发起一个请求,后台就会创建一个新的线程来进行处理。而一直开新线程的开销是很大的,这样会严重影响系统的性能。
3.怎么创建线程池?
答:创建ExecutorService接口的实现类,创建方式有两种
4.创建线程过多导致的问题?
答: 创建线程过多会占用CPU资源的,导致卡顿
三、两种线程池的创建方式
方式一:使用ExecutorService的实现类ThreadPoolExecutor去自己创建一个线程池对象。
(1)处理Runnable任务
步骤:
1.创建Runnable线程类
2.在main方法里面创建ExecutorService pool = new ThreadPoolExecutor();---括号里面填上线程的定义规则
3.创建Runnable target = new MyRunnable();
4.创建线程pool.execute(target);
代码例子:
package bao; import java.util.concurrent.*; public class Test { public static void main(String[] args) { /* //一、1.自己定义一个线程池对象----多态的写法 * 3个核心员工(3个核心线程) * 5个总员工,那就是临时工是2个(总线程5个) * 6s,TimeUnit.SECONDS----临时工没事干就被销毁辞退了 * 员工最多只能5个 * Executors.defaultThreadFactory()-----默认线程工厂 *new ThreadPoolExecutor.AbortPolicy()-----拒绝别人 * */ ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()); //5.new创建线程 Runnable target = new MyRunnable(); //线程多少来自于上面自定义 //因为线程方法都一样。调用有可能一下子就调用线程4-3-1了,那剩余的有可能会分配到任务,有可能闲着 pool.execute(target);//核心线程1 pool.execute(target);//核心线程2 pool.execute(target);//核心线程3 //创建临时线程(线程名字都一样,5个不一定哪个是核心,哪个是临时,分辨不出来) pool.execute(target);//线程4 pool.execute(target);//线程5 //为什么一些超过5条线程还能运行不报错呢?比如线程池里面只有5个位置,但是看着这么多线程都在,以为可以调用超过5个,一旦调用超过了5个就会报错 //关闭线程(几乎不会用到,了解了就好了) //pool.shutdownNow();立即强制关掉,即使任务没有完成也会被关掉,会丢失任务 //pool.shutdown();等待任务完成后再关闭,相对柔和 } } //二、创建线程对象类 //2.创建线程类 class MyRunnable implements Runnable{ //3.重写run方法 @Override public void run() { //4.定义线程要执行的任务 for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName()+"输出了:月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务 } } }
运行结果:
pool-1-thread-3输出了:月饼0
pool-1-thread-1输出了:月饼0
pool-1-thread-2输出了:月饼0
pool-1-thread-1输出了:月饼1
pool-1-thread-3输出了:月饼1
pool-1-thread-1输出了:月饼2
pool-1-thread-2输出了:月饼1
pool-1-thread-1输出了:月饼3
pool-1-thread-3输出了:月饼2
pool-1-thread-1输出了:月饼4
pool-1-thread-2输出了:月饼2
pool-1-thread-3输出了:月饼3
pool-1-thread-2输出了:月饼3
pool-1-thread-3输出了:月饼4
pool-1-thread-1输出了:月饼0
pool-1-thread-3输出了:月饼0
pool-1-thread-2输出了:月饼4
pool-1-thread-3输出了:月饼1
pool-1-thread-1输出了:月饼1
pool-1-thread-3输出了:月饼2
pool-1-thread-1输出了:月饼2
pool-1-thread-3输出了:月饼3
pool-1-thread-1输出了:月饼3
pool-1-thread-3输出了:月饼4
pool-1-thread-1输出了:月饼4
(2)处理Callable任务
步骤:
1.创建Callable线程类
2.在main方法里面创建ExecutorService pool = new ThreadPoolExecutor();---括号里面填上线程的定义规则
3. 创建线程Future f1 = pool.submit(new MyCallable(这里输入传入的值));
4.输出结果System.out.println(f1.get());//有异常直接抛出就好了
代码例子:
package bao; import java.util.concurrent.*; public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { //二、4.自定义线程的规则(详情看上一题) ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()); //5.把任务给线程池 Future<String> f1 = pool.submit(new MyCallable(100)); Future<String> f2 = pool.submit(new MyCallable(200)); Future<String> f3 = pool.submit(new MyCallable(300)); Future<String> f4 = pool.submit(new MyCallable(400)); Future<String> f5 = pool.submit(new MyCallable(500)); //6.输出结果 System.out.println(f1.get());//有异常直接抛出就好了 System.out.println(f2.get()); System.out.println(f3.get()); System.out.println(f4.get()); System.out.println(f5.get()); } } //一、1.创建线程任务类Callable class MyCallable implements Callable<String>{ private int n; public MyCallable(int n){ this.n=n; } //2.重写Call方法 @Override public String call() throws Exception { //3.写线程要执行的具体任务代码 int sum = 0; for (int i = 0; i < n; i++) { sum+=i; } return Thread.currentThread().getName()+"执行1-"+n+"的和是"+sum; } }
运行结果:
pool-1-thread-1执行1-100的和是4950
pool-1-thread-2执行1-200的和是19900
pool-1-thread-3执行1-300的和是44850
pool-1-thread-2执行1-400的和是79800
pool-1-thread-3执行1-500的和是124750
方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象。(不适合做大型互联网场景的线程池方案,阿里巴巴手册不允许使用)
这个方式使用的例子方式就是固定了线程的数量使用。
步骤:
1.创建线程类
2.在main方法里面创建ExecutorService pool = Executors.newFixedThreadPool(这里固定线程数量);
3.创建线程pool.execute(new MyRunnable());
代码例子:
package bao; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { //二、5.创建固定线程池数据的线程池 ExecutorService pool = Executors.newFixedThreadPool(3);//这里固定线程池里面只能有3个线程 //6.创建线程 pool.execute(new MyRunnable());//线程1 pool.execute(new MyRunnable());//线程2 pool.execute(new MyRunnable());//线程3 //创建多余的线程也不要了,看都不看,就算上面的线程睡眠了 } } //一、1.创建线程对象类 //2.创建线程类 class MyRunnable implements Runnable{ //3.重写run方法 @Override public void run() { //4.定义线程要执行的任务 for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName()+"输出了:月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务 } } }
运行结果:
pool-1-thread-3输出了:月饼0
pool-1-thread-2输出了:月饼0
pool-1-thread-1输出了:月饼0
pool-1-thread-2输出了:月饼1
pool-1-thread-3输出了:月饼1
pool-1-thread-2输出了:月饼2
pool-1-thread-1输出了:月饼1
pool-1-thread-2输出了:月饼3
pool-1-thread-3输出了:月饼2
pool-1-thread-2输出了:月饼4
pool-1-thread-1输出了:月饼2
pool-1-thread-3输出了:月饼3
pool-1-thread-1输出了:月饼3
pool-1-thread-3输出了:月饼4
pool-1-thread-1输出了:月饼4
旁白:线程池的出现就是为了避免资源的浪费,合理分配线程的资源,创建方式有两种,主要用第一种,第二种工具线程不建议使用。