how2j.cn


工具版本兼容问题
每一个线程的启动和结束都是比较消耗时间和占用资源的。

如果在系统中用到了很多的线程,大量的启动和结束动作会导致系统的性能变卡,响应变慢。

为了解决这个问题,引入线程池这种设计思想。

线程池的模式很像生产者消费者模式,消费的对象是一个一个的能够运行的任务

本视频是解读性视频,所以希望您已经看过了本知识点的内容,并且编写了相应的代码之后,带着疑问来观看,这样收获才多。 不建议一开始就观看视频



30分57秒
本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)



步骤 1 : 线程池设计思路   
步骤 2 : 开发一个自定义线程池   
步骤 3 : 测试线程池   
步骤 4 : 使用java自带线程池   
步骤 5 : 练习- 借助线程池同步查找文件内容   
步骤 6 : 答案- 借助线程池同步查找文件内容   

步骤 1 :

线程池设计思路

线程池的思路和生产者消费者模型是很接近的。
1. 准备一个任务容器
2. 一次性启动10个 消费者线程
3. 刚开始任务容器是空的,所以线程都wait在上面。
4. 直到一个外部线程往这个任务容器中扔了一个“任务”,就会有一个消费者线程被唤醒notify
5. 这个消费者线程取出“任务”,并且执行这个任务,执行完毕后,继续等待下一次任务的到来。
6. 如果短时间内,有较多的任务加入,那么就会有多个线程被唤醒,去执行这些任务。

在整个过程中,都不需要创建新的线程,而是循环使用这些已经存在的线程
线程池设计思路
步骤 2 :

开发一个自定义线程池

这是一个自定义的线程池,虽然不够完善和健壮,但是已经足以说明线程池的工作原理

缓慢的给这个线程池添加任务,会看到有多条线程来执行这些任务。
线程7执行完毕任务后,又回到池子里,下一次任务来的时候,线程7又来执行新的任务。
开发一个自定义线程池
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秒钟向线程池中添加任务

然后间隔时间越来越短,执行任务的线程还没有来得及结束,新的任务又来了。
就会观察到线程池里的其他线程被唤醒来执行这些任务
测试线程池
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"); } }); } }
步骤 5 :

练习- 借助线程池同步查找文件内容

Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
练习-同步查找文件内容 ,如果文件特别多,就会创建很多的线程。 改写这个练习,使用线程池的方式来完成。

初始化一个大小是10的线程池

遍历所有文件,当遍历到文件是.java的时候,创建一个查找文件的任务,把这个任务扔进线程池去执行,继续遍历下一个文件
步骤 6 :

答案- 借助线程池同步查找文件内容

在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
答案- 借助线程池同步查找文件内容
package multiplethread; import java.io.File; import java.io.FileReader; import java.io.IOException; public class SearchFileTask implements Runnable{ private File file; private String search; public SearchFileTask(File file,String search) { this.file = file; this.search= search; } public void run(){ String fileContent = readFileConent(file); if(fileContent.contains(search)){ System.out.printf( "线程: %s 找到子目标字符串%s,在文件:%s%n",Thread.currentThread().getName(), search,file); } } public String readFileConent(File file){ try (FileReader fr = new FileReader(file)) { char[] all = new char[(int) file.length()]; fr.read(all); return new String(all); } catch (IOException e) { e.printStackTrace(); return null; } } }
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() { 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(); } task.run(); } } } }
package multiplethread; import java.io.File; public class TestThread { static ThreadPool pool= new ThreadPool(); public static void search(File file, String search) { if (file.isFile()) { if(file.getName().toLowerCase().endsWith(".java")){ SearchFileTask task = new SearchFileTask(file, search); pool.add(task); } } if (file.isDirectory()) { File[] fs = file.listFiles(); for (File f : fs) { search(f, search); } } } public static void main(String[] args) { File folder =new File("e:\\project"); search(folder,"Magic"); } }


HOW2J公众号,关注后实时获知布最新的教程和优惠活动,谢谢。


问答区域    
2018-04-02 交作业
夜神1997



package multiplethread;

import java.io.File;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.LinkedBlockingQueue;

public class SearchFilePool{
	
	public static void searchStr(File f, String str, ThreadPoolExecutor tpe){
		if(null == str){
			System.out.println("查找内容错误");
			return;
		}
		
		File[] fs = f.listFiles();
		if(fs.length == 0){
			return;
		}
		else{
			for(int i = 0; i < fs.length; i++){
				if(fs[i].isDirectory()){
					searchStr(fs[i], str, tpe);
				}
				else{
					String name = fs[i].getName();
					if(name.length() > 5 && name.substring(name.length() - 5, name.length()).equals(".java")){
						execute(fs[i], tpe, str);	//在这里用匿名类的话i不是final型,会出错
					}
				}
			}
		}
	}
	
	public static void execute(File f , ThreadPoolExecutor tpe, String str){
		tpe.execute(new Runnable(){
			@Override
			public void run(){
				try(
						FileInputStream fis = new FileInputStream(f);
						BufferedInputStream bis = new BufferedInputStream(fis);
					){
					byte[] c = new byte[(int)f.length()];
					bis.read(c);
					if(new String(c).contains(str)){
						System.out.printf("找到子目标字符串%s,在文件:%s%n", str, f.toString());
					}
					
				}catch(IOException e){
					e.printStackTrace();
				}
			}
		});
	}
	
	public static void main(String[] args){
		ThreadPoolExecutor tpe = new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
		
		File f = new File("e:/project");
		String str = "stream";
		searchStr(f, str, tpe);
	}
}

							






答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2018-03-29 我认为run方法中tasks.notifyAll()这句代码是多余的,原因如下: 。。。 请指正?
ding1988
我认为run方法中tasks.notifyAll()这句代码是多余的,原因如下: 。。。 请指正? public void run() { // TODO Auto-generated method stub System.out.println("启动: " + this.getName()); while (true) { synchronized (tasks) { while (tasks.isEmpty()) { try { tasks.wait(); } catch (InterruptedException e) { // TODO: handle exception e.printStackTrace(); } } task = tasks.removeLast(); tasks.notifyAll(); } System.out.println(this.getName() + " 获取到任务,并执行"); task.run(); } } 这段代码中的tasks.notifyAll();作用是什么? 在add方法中 synchronized (tasks) { tasks.add(r); tasks.notifyAll(); } 添加完任务之后,是有一个通知启动的。








答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到




2018-03-17 关于任务容器类型
2018-01-26 我只想问10个准备线程的线程池,最多能放多少任务呢(就是要让10个线程全被用光了,结果任务放不进去了)。。。
2018-01-02 Exception in thread "pool-1-thread-3" java.lang.OutOfMemoryError: Java heap space
2017-12-04 关于步骤2 // 试图消费任务的线程 的疑问
2017-11-23 开发一个自定义线程池,用notify也可以吧?
2017-11-22 线程池中synchronized保护当前1个线程安全,那么其他9个线程是先停止等待tasks被释放,还是先wait休眠?
2017-09-27 查找文件字符的程序为什么不能应用于查找excel里的字符?
2017-09-26 为何线程池还没创建完 线程就开始接任务了?
2017-09-22 发现一个问题,LinkedList你用的插入和取出是add和removeLast,也就是说先进入集合的任务不一定先得到执行
2017-09-05 run里notifyAll的意义是?注释没看明白
2017-08-27 步骤2中,运行示例代码无法得到预期的结果
2017-07-06 步骤 2 : 开发一个自定义线程池
2017-05-07 开发自定义线程池例子中
2017-04-29
2017-04-29
2017-04-21 关于task=tasks.removeLast();
2017-04-01 在TaskConsumerThread中,tasks只是一个集合,为什么要任务栈tasks.wait(),而不是这个线程阻塞呢?
2017-03-08 寫錯
2017-01-18 TaskConsumeThread中的Runnable task
2016-10-28 步骤 2 : 开发一个自定义线程池




提问之前请登陆
关于 JAVA 中级-多线程-线程池 的提问

尽量提供截图代码异常信息,有助于分析和解决问题。 也可进本站QQ群交流: 620943819
站长会在每个工作日早上尽量回答提问(如果有漏掉没有回答的,请进群提醒一下)
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
站长是玻璃心,提问的时候请语气温柔些 kiss~
截止2017-5-19日累计提问 1638个,站长回答了 1546个
截止2017-8-15日累计提问 2788个,站长回答了 2544个

上传截图