正文
Java多线程遍历文件夹,广度遍历加多线程加深度遍历结合
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
复习IO操作,突然想写一个小工具,统计一下电脑里面的Java代码量还有注释率,最开始随手写了一个递归算法,遍历文件夹,比较简单,而且代码层次清晰,相对易于理解,代码如下:(完整代码贴在最后面,前面是功能实现代码)
public static void visitFile(File file) {if (file != null) {// 如果是文件夹if (file.isDirectory()) {// 统计文件夹下面的所有文件路径File[] fls = file.listFiles();// 如果父文件夹有内容if (fls != null) {// 那么遍历子文件for (int i = 0; i < fls.length; i++) {// 继续判断文件是文件夹还是文件,嵌套循环visitFile(fls[i]);}}} else// 如果是文件{// 判断文件名是不是.java类型String fname = file.getName();if (fname.endsWith(".java")) {Sysotem.out.println("java文件:"+fname);}}}}
但是写成小工具后,在使用中我发现了它遍历速度还是比较慢的问题,递归算法本身运行效率低,占用空间也非常大,每一次调用都要出现方法压栈弹栈,系统开销大。所以我想把它改成非递归算法,我有两个想法:1.打开父文件夹(父亲)之后,遍历子文件夹(儿子),如果是目录就列出子文件夹的子文件夹(儿子的儿子),记录下来,但是不继续打开;如果遇到的是我需要的文件,那么就加入文件集合中,重复。代码如下:
File fl = this.file;//根文件(父亲)ArrayList<File> flist = new ArrayList<File>();//文件夹目录列表1ArrayList<File> flist2 = new ArrayList<File>();//文件夹目录列表2ArrayList<File> tmp = null, next = null;//集合应用变量,tmp记录子文件夹的目录列表(儿子),next记录子文件夹的子文件夹列表(儿子的儿子)flist.add(fl);//列表1记录根文件// 广度遍历层数控制int loop = 0;//控制循环层数while (loop++ < 3) {// 此处只循环了三层tmp = tmp == flist ? flist2 : flist;//此处比较绕,实现功能是tmp和next两个引用变量互换地址next = next == flist2 ? flist : flist2;for (int i = 0; i < tmp.size(); i++) {//遍历子文件夹fl = tmp.get(i);if (fl != null) {if (fl.isDirectory()) {//如果遇到目录File[] fls = fl.listFiles();if (fls != null) {next.addAll(Arrays.asList(fls));//将子文件夹的子文件夹目录列表一次全部加入next列表}} else {if (fl.getName().endsWith(type)) {papList.add(fl);//如果是需要的文件,就加入papList列表}}}}tmp.clear();//清空子文件夹列表,因为已经遍历子文件夹结束,后面需要一个空的列表继续装东西}
2.第二种思路是打开父文件夹后,遍历子文件夹,然后遇到目录就继续打开,直到没有目录才返回上一层,这个思路和递归遍历算法一样,看递归的算法更好理解,代码如下:
// 非递归深度遍历算法void quickFind() throws IOException {// 使用栈,进行深度遍历Stack<java.io.File> stk = new Stack<File>();stk.push(this.file);//父文件压栈File f;while (!stk.empty()) {//当栈不为空,就一直循环压栈出栈过程。f = stk.pop();//弹出栈顶元素if (f.isDirectory()) {//如果栈顶是目录File[] fs = f.listFiles();//打开栈顶子目录if (fs != null)for (int i = 0; i < fs.length; i++) {stk.push(fs[i]);//将栈顶子目录依次压栈}} else {if (f.getName().endsWith(type)) {// 记录所需文件的信息,加入集合papList.add(f);}}}}
上面的两种非递归算法,速度上相差无几,相对于递归算法比较难于理解,但是速度真的快一点,而且占用内存比较小,如果使用递归,当递归层数比较多的时候对系统资源消耗巨大,甚至会造成jvm崩溃,非递归算法没有这个隐患,深度遍历和广度遍历在遍历很多文件时,深度遍历稍微占优势,速度会快一点,但是数据有浮动。后面我又复习到多线程,我就想把多线程加进去,会不会更快。然后我就建立了一个线程池:
// 创建线程池,一共THREAD_COUNT个线程可以使用ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);//新建固定线程数的线程池 for (File file : next) {pool.submit(new FileThread(file, type));//提交对象到线程池,FileThread类是我自定义的内部类,重写了Runnable接口中的run方法。}pool.shutdown();//结束// 必须等到所有线程结束才可以让主线程退出,不然就一直阻塞while (!pool.isTerminated());
线程池的好处是统一管理线程,不用一直开辟新的线程,开辟线程很消耗系统资源,线程池里面的线程可以循环使用,程序结束了再释放,适用于频繁切换任务的情况,在Tcp/ip网络编程中常见。加入多线程我也有两种想法,1.我先想到多线程就是几个兄弟一起干活,速度肯定快,所以我每遍历一个文件夹就开辟一个新的线程,代码如下:
void judge(File f) { if (f != null) {if (f.isDirectory()) {// 如果是目录File[] fs = f.listFiles();if (fs != null)FileOP.BigFileList.addAll(Arrays.asList(fs));// 一起加到BigFileList中,前面有一个for循环遍历BigFileList,遍历一次开辟一个新线程} else {if (f.getName().endsWith(type)) {FileOP.papList.add(f);// 我们要的文件记录下来}}}}
但是想法很美好,现实很残酷,这种方法速度比递归算法还要慢,开辟新线程(此处还没有应用线程池,每次都new Thread();)的时间,加上垃圾回收的时间远超过递归算法遍历文件夹的时间。而且多线程也并不是可以无限个,一般来说CPU大多只支持四线程,但是线程数大于四时,cpu通过调度算法分配程序执行的时间,常见先进先出,短作业优先,时间片轮转调度,高优先权调度算法,我一般设置最大线程数是CPU支持线程数的3倍,根据我实际测试,设置成100个线程比设置成12个线程,程序执行时间没有短多少,反而在CPU占用率高的时候100线程更慢。
所以我又想,怎么才能发挥多线程的优势呢,首先肯定要把一个任务分成多个任务,这也有两个思路:1.先用递归深度遍历算法遍历文件夹,当遇到比较大的文件夹,比如说包含1000个子文件夹就记录下来,然后跳过继续遍历其他的文件夹,此时主线程有一个while循环一直在检查有没有新的大文件夹出现,如果有就开一个新线程去遍历大文件夹,代码如下:
void findAll(File f) {if (f != null) { if (f.isDirectory()) {// 如果是目录File[] fs = f.listFiles();if (fs == null) {return;} * if (fs.length > FileOP.THREAD_COUNT * 100) {// * 当文件夹的目录数量大于线程数的百倍,记录下来,待会用多线程慢慢数 FileOP.BigFileList.add(f); * // 这记录的都是后面要用多线程来数一数的 } else {for (int i = 0; i < fs.length; i++) {findAll(fs[i]);// 如果文件数少,就递归一下}}} else {// 需要的文件放进pap集合if (f.getName().endsWith(type)) {FileOP.papList.add(f);}}}}
实际效果比不上单纯的递归算法速度快,难受,因为我记录的文件夹虽然是“大文件夹”,但是可能并不深,递归一两层就结束了,这时候开新线程消耗更大,所以我就想到自上而下的分配任务,比如说我们让程序遍历C 盘所有的Java文件,程序可以先获取C盘根目录列表,然后开辟线程池,每一个线程执行一个子目录的遍历,遍历子文件夹时换成非递归深度遍历算法,算法如下:
package com.ycs; import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.math.BigDecimal;import java.util.ArrayList;import java.util.Arrays;import java.util.Stack;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors; public class FileList {// 控制线程数,最优选择是处理器线程数*3,本机处理器是4线程private final static int THREAD_COUNT = 12;// 线程共享数据,保存所有的type文件private ArrayList<File> papList = new ArrayList<File>();// 保存文件附加信息private ArrayList<String> contenList = new ArrayList<String>();// 当前文件或者目录private File file; // 所需的文件类型private String type; public FileList() {super();// TODO Auto-generated constructor stub} public FileList(String f, String type) {super();this.file = new File(f);this.type = type;} public ArrayList<String> getContenList() {return contenList;} // 内部类继承runnable接口,实现多线程class FileThread implements Runnable {private File file;private String type; public FileThread(File file, String type) {super();this.file = file;this.type = type;} public FileThread() {super();// TODO Auto-generated cosnstructor stub} @Overridepublic void run() {try {quickFind();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}} // 非递归深度遍历算法void quickFind() throws IOException {// 使用栈,进行深度遍历Stack<java.io.File> stk = new Stack<File>();stk.push(this.file);File f;while (!stk.empty()) {f = stk.pop();if (f.isDirectory()) {File[] fs = f.listFiles();if (fs != null)for (int i = 0; i < fs.length; i++) {stk.push(fs[i]);}} else {if (f.getName().endsWith(type)) {// 记录所需文件的信息papList.add(f);}}}}} public ArrayList<File> getPapList() {// 外部接口,传递遍历结果return papList;} // 深度遍历算法加调用线程池void File() {File fl = this.file;ArrayList<File> flist = new ArrayList<File>();ArrayList<File> flist2 = new ArrayList<File>();ArrayList<File> tmp = null, next = null;flist.add(fl);// 广度遍历层数控制int loop = 0;while (loop++ < 3) {// 最优循环层数是3层,多次实验得出tmp = tmp == flist ? flist2 : flist;next = next == flist2 ? flist : flist2;for (int i = 0; i < tmp.size(); i++) {fl = tmp.get(i);if (fl != null) {if (fl.isDirectory()) {File[] fls = fl.listFiles();if (fls != null) {next.addAll(Arrays.asList(fls));}} else {if (fl.getName().endsWith(type)) {papList.add(fl);}}}}tmp.clear();} // 创建线程池,一共THREAD_COUNT个线程可以使用ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT); for (File file : next) {pool.submit(new FileThread(file, type));}pool.shutdown();// 必须等到所有线程结束才可以让主线程退出,不然就一直阻塞while (!pool.isTerminated());} void info(File file) throws IOException {InputStream inputStream = new FileInputStream(file);byte[] chs = new byte[(int) file.length()];inputStream.read(chs);inputStream.close();String javaCode = new String(chs);String[] lines = javaCode.split("\n");int find = lines.length;// 实际代码行数int counts = find;// 加上注释的行数int zhushi = 0;for (int i = 0; i < lines.length; i++) {lines[i] = lines[i].trim();if (lines[i].length() == 0) {counts--;find--;} else if (lines[i].startsWith("//")) {// System.out.println("单行注释:"+lines[i]);find--;zhushi++;} else if (lines[i].indexOf("/*") != -1) {find--;zhushi++;while (lines[i].indexOf("*/") == -1) {// System.out.println(lines[i]);find--;zhushi++;i++;}}} double zc = ((double) zhushi / counts) * 100;BigDecimal b = new BigDecimal(zc);double zcc = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();String s = file.getName() + "代码行数:" + find + "\t注释行数:" + zhushi + "\t 注释率:" + zcc + "%"; contenList.add(s);}}
这一次果然快了很多,但是幅度不大,通过分析我发现然来C盘根目录的文件夹也不是每一个大小都一样的,有一些文件夹里面文件特别多,有一些就很少,而且只遍历C盘根目录,然后再调用多线程,可能文件夹数量没有线程数多,我应该多遍历几层,再调用多线程,多次实验后我发现只有遍历三层才是最快的,原理不明,但是遍历一层、两层、四层、五层程序执行时间都比较长,三层是一个神奇的点。最后的实验结果:多线程遍历,文件越多约占优势,16万个文件,单线程递归算法需要8-9秒,单线程非递归需要7-8秒,三种结合只需要3-4秒,而且在文件数比较少的时候,此方法也有比较大幅度的提升,快一两百毫秒。
最后贴上程序运行图:
嗯,贴不了。。。
完整代码就是上面那个,创建一个对象,给构造函数传入文件路径(String)和文件类型(String)就可以了。
小白之作,轻喷轻喷
原文地址:https://blog.csdn.net/qq_24833939/article/details/79222444