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公众号,关注后实时获知布最新的教程和优惠活动,谢谢。


问答区域    
2019-01-11 问题
niddhogg



话说直接遍历系统盘会出现一个java.lang.NullPointerException的异常,怎么解决
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Testmutithread {
	static Threadpool pool = new Threadpool();
	public static void main(String[]args) {
		File f = new File("E:\\");//怎么样实现遍历系统盘
		bianli(f,"magic");
    }
	public static void bianli(File z,String search){	
			if(z.isFile()&&z.getName().toLowerCase().endsWith(".java")){
				Runnable task = new Runnable() {
	                @Override
	                public void run() {
	                searchf(z,search);  
	                }
	            }; 
	            pool.add(task);
			} 
			if(z.isDirectory()){
				File[] h = z.listFiles();
				for(File c : h){
					bianli(c, search);
				}
			}
	}
	public static void searchf(File z, String search){
		try(FileReader fr = new FileReader(z)){
					 char[] all = new char[(int) z.length()];
			            fr.read(all);
			            String filecontent = new String(all);
			            if(filecontent.contains(search)){
			            	System.out.printf("找到子目标字符串%s,在文件:%s%n",search,z);
			            }
			        } catch (IOException e) {
			            e.printStackTrace();
			        }
	}
}

							






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





2018-11-23 有人能告诉我这个问题怎样解决吗
29岁高龄学者



//这里应该给个什么参数才能使整块代码要么执行全部,要么不执行; 老是出现执行到一半代码,CPU把资源给了另一个线程,导致显示的结果不理想 synchronized (Thread.currentThread()) { 图片是程序分别执行的结果
package Filetext;

import java.io.File;
import java.io.FileReader;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class SearchFile{
	ThreadPoolExecutor thp=new ThreadPoolExecutor(10, 15, 30,TimeUnit.SECONDS, 
				new LinkedBlockingQueue<Runnable>());
	
	void search(File f,String str){
		File ff[] = f.listFiles();
		for(int i=0;i<ff.length;i++){
			if(ff[i].isFile() && (ff[i].getName().matches(".*.java"))){//如果发现JAVA文件
				final File fr=ff[i];// 匿名类里面的参数只能是final
				final String str2=str;
				thp.execute(new Runnable(){//如果是判断出来是文件就把任务扔进线程池
					public void run() {// 以下是任务执行代码
						// TODO Auto-generated method stub
						//这里应该给个什么参数才能使整块代码要么执行全部,要么不执行,老是出现执行到一半代码,CPU把资源给了另一个线程
						synchronized (Thread.currentThread()) {
		            		FileReader fin = null;
		            		try {
		            			String s;
		            			fin = new FileReader(fr);
		            			char c[] = new char[(int) fr.length()];
			        			fin.read(c);// 读取到字符数组
			        			s = String.valueOf(c);// 转化成字符串
			        			// System.out.println(s);
			        			fin.close();
			        			if (s.indexOf(str2) != (-1)) {
			        				System.out.println(fr.getPath() + "  存在字符串\t" + str2);
			        				System.out.println("这是线程"+Thread.currentThread().getName()+"搜出来的\n");
			        			}
		            		} catch (Exception e) {
		            			// TODO Auto-generated catch bloc
		            		}
		            		// run方法不能外抛异常,只能用try/catch自己处理了
		            		finally {
		            			try {
		            				fin.close();
		            			} catch (Exception e) {
		        			}
		            		}
						}
					}//到这来为止都是任务执行代码
	            });
			}
			else if(ff[i].isDirectory()){//如果是文件就递归寻找下一级
				search(ff[i],str);
			}
		}
	}
	
} 

public class NewSearch {
	//用另一个类调用search方法,模拟SearchFile封装后调用search方法
	public static void main(String[] args) {
		new SearchFile().search(new File("d:\\lol"),"99");
	}
	
	
}

							


2 个答案

29岁高龄学者 答案时间:2018-11-23
有点无语,我发现里面的参数为“”也能达到一样的效果

29岁高龄学者 答案时间:2018-11-23
我去,把参数改成thp synchronized (thp) 就不会执行到一半就去执行另一个线程的代码了,没问题了,什么原理谁给解释下




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





2018-11-21 步骤2中的任务并不是线程安全的。
2018-11-21 这段代码中的任务并不是安全的
2018-11-06 请问步骤2中 TaskConsumeThread 中 为什么要用 while(tasks.isEmpty) 而不能用 if(tasks.isEmpty) ? 不是已经有while(true)循环了嘛
2018-10-25 作业
2018-10-18 TaskConsumeThread 的run方法最后一行为什么不用new Thread(task).start()?
2018-10-18 TaskConsumeThread 的run方法最后一行为什么不用new Thread(task).start()?
2018-10-16 作业
2018-10-16 run()中的tasks.notifyAll();问题
2018-10-15 作业
2018-10-15 作业
2018-09-09 交作业
2018-08-21 task.run();的作用什么?删去这句也能运行
2018-08-07 作业
2018-08-07 作业
2018-07-18 我用java自带的线程池来写,能跑出正确结果,不知道符不符合题意
2018-06-23 用多线程跑之前的C:\Windows文件遍历
2018-06-06 步骤2:开发一个线程池
2018-05-10 给各位提供一下我的代码,没有看答案,手打
2018-05-10 我没看答案写的,你们谁看过的帮我分析一下
2018-04-02 交作业
2018-03-29 我认为run方法中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群交流: 902680467
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
在已经存在的几千个提问里,有相当大的比例,是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本,可以节约自己大量的学习时间。 站长把教学中用的软件版本整理了,都统一放在了这里, 方便大家下载: http://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图