每一个线程的启动和结束都是比较消耗时间和占用资源的。
如果在系统中用到了很多的线程,大量的启动和结束动作会导致系统的性能变卡,响应变慢。
为了解决这个问题,引入线程池这种设计思想。
线程池的模式很像生产者消费者模式,消费的对象是一个一个的能够运行的任务
步骤1:线程池设计思路
步骤2:开发一个自定义线程池
步骤3:测试线程池
步骤4:使用java自带线程池
步骤5:练习- 借助线程池同步查找文件内容
步骤6:答案- 借助线程池同步查找文件内容
步骤 1 : 线程池设计思路
线程池的思路和生产者消费者模型是很接近的。
1. 准备一个任务容器
2. 一次性启动10个 消费者线程
3. 刚开始任务容器是空的,所以线程都wait在上面。
4. 直到一个外部线程往这个任务容器中扔了一个“任务”,就会有一个消费者线程被唤醒notify
5. 这个消费者线程取出“任务”,并且执行这个任务,执行完毕后,继续等待下一次任务的到来。
6. 如果短时间内,有较多的任务加入,那么就会有多个线程被唤醒,去执行这些任务。
在整个过程中,都不需要创建新的线程,而是循环使用这些已经存在的线程
![线程池设计思路](https://i-blog.csdnimg.cn/blog_migrate/397d0c3819adfe9e8fdc3dea8482f22a.png)
步骤 2 : 开发一个自定义线程池
这是一个自定义的线程池,虽然不够完善和健壮,但是已经足以说明线程池的工作原理
缓慢的给这个线程池添加任务,会看到有多条线程来执行这些任务。
线程7执行完毕任务后,又回到池子里,下一次任务来的时候,线程7又来执行新的任务。
![开发一个自定义线程池](https://i-blog.csdnimg.cn/blog_migrate/cbaae2d2a30db64705a068f119585c79.png)
package multiplethread; import java.util.LinkedList; public class ThreadPool { // 线程池大小 int threadPoolSize; // 任务容器 LinkedList<Runnable> tasks = new LinkedList<Runnable>(); // 试图消费任务的线程 public ThreadPool() { threadPoolSize = 10 ; // 启动10个任务消费者线程 synchronized (tasks) { for ( int i = 0 ; i < threadPoolSize; i++) { new TaskConsumeThread( "任务消费者线程 " + i).start(); } } } public void add(Runnable r) { synchronized (tasks) { tasks.add(r); // 唤醒等待的任务消费者线程 tasks.notifyAll(); } } class TaskConsumeThread extends Thread { public TaskConsumeThread(String name) { super (name); } Runnable task; public void run() { System.out.println( "启动: " + this .getName()); while ( true ) { synchronized (tasks) { while (tasks.isEmpty()) { try { tasks.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } task = tasks.removeLast(); // 允许添加任务的线程可以继续添加任务 tasks.notifyAll(); } System.out.println( this .getName() + " 获取到任务,并执行" ); task.run(); } } } } |
package multiplethread; public class TestThread { public static void main(String[] args) { ThreadPool pool = new ThreadPool(); for ( int i = 0 ; i < 5 ; i++) { Runnable task = new Runnable() { @Override public void run() { //System.out.println("执行任务"); //任务可能是打印一句话 //可能是访问文件 //可能是做排序 } }; pool.add(task); try { Thread.sleep( 1000 ); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } |
步骤 3 : 测试线程池
创造一个情景,每个任务执行的时间都是1秒
刚开始是间隔1秒钟向线程池中添加任务
然后间隔时间越来越短,执行任务的线程还没有来得及结束,新的任务又来了。
就会观察到线程池里的其他线程被唤醒来执行这些任务
![测试线程池](https://i-blog.csdnimg.cn/blog_migrate/a748735ed95027470675f8b9df398bb9.png)
package multiplethread; public class TestThread { public static void main(String[] args) { ThreadPool pool= new ThreadPool(); int sleep= 1000 ; while ( true ){ pool.add( new Runnable(){ @Override public void run() { //System.out.println("执行任务"); try { Thread.sleep( 1000 ); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }); try { Thread.sleep(sleep); sleep = sleep> 100 ?sleep- 100 :sleep; } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } |
步骤 4 : 使用java自带线程池
java提供自带的线程池,而不需要自己去开发一个自定义线程池了。
线程池类ThreadPoolExecutor在包java.util.concurrent下
ThreadPoolExecutor threadPool= new ThreadPoolExecutor( 10 , 15 , 60 , TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); |
第一个参数10 表示这个线程池初始化了10个线程在里面工作
第二个参数15 表示如果10个线程不够用了,就会自动增加到最多15个线程
第三个参数60 结合第四个参数TimeUnit.SECONDS,表示经过60秒,多出来的线程还没有接到活儿,就会回收,最后保持池子里就10个
第四个参数TimeUnit.SECONDS 如上
第五个参数 new LinkedBlockingQueue() 用来放任务的集合
execute方法用于添加新的任务
package multiplethread; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(String[] args) throws InterruptedException { ThreadPoolExecutor threadPool= new ThreadPoolExecutor( 10 , 15 , 60 , TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); threadPool.execute( new Runnable(){ @Override public void run() { // TODO Auto-generated method stub System.out.println( "任务1" ); } }); } } |
更多内容,点击了解: https://how2j.cn/k/thread/thread-threadpool/357.html