java 多线程 扫描,多线程扫描文件夹耗时方法分析

在这里Java的方法中有线程递归，不懂得用什么方法求运行时间遇到一个有趣的问题，多线程扫描文件夹求运行时间。一般这种扫描文件夹耗时好像都是用的递归遍历一下进行计时，头一次看到这种一个文件夹一个线程的，这里按照原问题楼主的想法试着解决一下。

刚开始我是采用静态变量，共享总耗时，把每个run方法耗时都加上。

package com.brewin.codetuning.test;

import java.io.File;

import java.text.SimpleDateFormat;

import java.util.Date;

public class ThreadDemo02

{

public static void main(String args[]) {

File file=new File("D:\\AA");

MyThread mt1 = new MyThread("线程1",file);

mt1.start();

}

}

class MyThread extends Thread

{

private String name;

private File file;

public static int sum;

static {

sum = 0;

}

public MyThread(String name,File file) {

this.name = name;

this.file=file;

}

@Override

public void run() {

long startTime = System.currentTimeMillis();

File[] files=file.listFiles();

if(files!=null &&files.length>0) {

for(File f:files) {

if(f.isDirectory()) {

new MyThread(f.getName(),f).start();

}

// 打印文件名不方便看最后的耗时打印，注释掉

// else {

// System.out.println(Thread.currentThread().getName()+":"+f);

// }

}

}

// try {

// Thread.sleep(5000);

// }

// catch (InterruptedException e) {

// // TODO Auto-generated catch block

// e.printStackTrace();

// }

long endTime = System.currentTimeMillis();

long usedTime = (endTime-startTime);

sum+=usedTime;

System.out.println(name + " 运行结束，耗时： "+usedTime+" ms，sum现为：" +MyThread.sum+" ms");

}

}

控制台打印的什么呢？下面截取最后一部分

storage 运行结束，耗时： 0 ms，sum现为：3156 ms

x509 运行结束，耗时： 1 ms，sum现为：3157 ms

implementations 运行结束，耗时： 1 ms，sum现为：3158 ms

implementations 运行结束，耗时： 1 ms，sum现为：3159 ms

但是实际并没有用到3秒多，很快就结束了。

下面是加了Thread.sleep(5000)的结果，更明显一些：

xs 运行结束，耗时： 5004 ms，sum现为：2611580 ms

implementations 运行结束，耗时： 5001 ms，sum现为：2606576 ms

traversers 运行结束，耗时： 5001 ms，sum现为：2616581 ms

多线程是并发执行，所以这个思路是错误的，不能计算他们的总和，而是要计算他们的最开始的时间和最后的时间。改变思路，在最开始时初始化一个开始时间，后面每次线程结束后都更新一下最后时间，求他们之间的差值就可以了。

package com.brewin.codetuning.test;

import java.io.File;

public class ThreadDemo02

{

public static void main(String args[]) {

File file=new File("D:\\AA");

MyThread mt1 = new MyThread("线程1",file);

mt1.start();

}

}

class MyThread extends Thread

{

private static long startTime;

private String name;

private File file;

static {

startTime = System.currentTimeMillis();

}

public MyThread(String name,File file) {

this.name = name;

this.file=file;

}

@Override

public void run() {

File[] files=file.listFiles();

if(files!=null &&files.length>0) {

for(File f:files) {

if(f.isDirectory()) {

new MyThread(f.getName(),f).start();

}

// 打印文件名不方便看最后的耗时打印，注释掉

// }else {

// System.out.println(Thread.currentThread().getName()+":"+f);

// }

}

}

long usedTime = System.currentTimeMillis()-startTime;

System.out.println(name + " 运行结束，已耗时： "+usedTime+" ms");

}

}

控制台最后一段打印如下：

io 运行结束，已耗时： 164 ms

proxy 运行结束，已耗时： 164 ms

dom 运行结束，已耗时： 164 ms

serialize 运行结束，已耗时： 165 ms

fsm 运行结束，已耗时： 165 ms

rmi 运行结束，已耗时： 166 ms

spi 运行结束，已耗时： 166 ms

tree 运行结束，已耗时： 166 ms

graph 运行结束，已耗时： 166 ms

util 运行结束，已耗时： 166 ms

utils 运行结束，已耗时： 167 ms

protocol 运行结束，已耗时： 167 ms

implementations 运行结束，已耗时： 167 ms

http 运行结束，已耗时： 167 ms

content 运行结束，已耗时： 167 ms

resolver 运行结束，已耗时： 167 ms

util 运行结束，已耗时： 168 ms

identity 运行结束，已耗时： 168 ms

keyvalues 运行结束，已耗时： 168 ms

x509 运行结束，已耗时： 169 ms

xs 运行结束，已耗时： 169 ms

serializer 运行结束，已耗时： 169 ms

util 运行结束，已耗时： 169 ms

xs 运行结束，已耗时： 169 ms

util 运行结束，已耗时： 169 ms

validation 运行结束，已耗时： 170 ms

undo 运行结束，已耗时： 170 ms

traversers 运行结束，已耗时： 170 ms

util 运行结束，已耗时： 170 ms

namingutil 运行结束，已耗时： 170 ms

exceptions 运行结束，已耗时： 170 ms

CORBA 运行结束，已耗时： 171 ms

xpath 运行结束，已耗时： 171 ms

transforms 运行结束，已耗时： 171 ms

utils 运行结束，已耗时： 171 ms

params 运行结束，已耗时： 171 ms

encryption 运行结束，已耗时： 171 ms

signature 运行结束，已耗时： 171 ms

output 运行结束，已耗时： 171 ms

implementations 运行结束，已耗时： 172 ms

closure 运行结束，已耗时： 172 ms

concurrent 运行结束，已耗时： 172 ms

orbutil 运行结束，已耗时： 172 ms

helper 运行结束，已耗时： 172 ms

keyresolver 运行结束，已耗时： 172 ms

storage 运行结束，已耗时： 172 ms

implementations 运行结束，已耗时： 173 ms

implementations 运行结束，已耗时： 173 ms

resolver 运行结束，已耗时： 173 ms

implementations 运行结束，已耗时： 173 ms

models 运行结束，已耗时： 174 ms

implementations 运行结束，已耗时： 174 ms

opti 运行结束，已耗时： 174 ms

text 运行结束，已耗时： 174 ms

rtf 运行结束，已耗时： 174 ms

utils 运行结束，已耗时： 175 ms

giopmsgheaders 运行结束，已耗时： 175 ms

reference 运行结束，已耗时： 175 ms

regex 运行结束，已耗时： 175 ms

threadpool 运行结束，已耗时： 175 ms

res 运行结束，已耗时： 176 ms

html 运行结束，已耗时： 177 ms

parser 运行结束，已耗时： 177 ms

看到原问题楼主有提到CountDownLatch ，找来文章看了一下，不是很适合这里，CountDownLatch计数器的初始大小要跟任务数的大小一致(跟线程数无关)，每执行一次任务，计数器减一(countDown)，await()方法会一直阻塞主线程，直到计数器的值减为0，才会释放锁，如此便可以达到确保所有任务都完成才继续下一步的效果。

但是本文场景是不断递归new出新线程，并且本文场景中要求任务数和线程数是相等的，无法确定任务数，就没办法初始化CountDownLatch 大小。

想要用CountDownLatch 的话只能加个统计方法，获得文件夹数量，如下：

package com.brewin.codetuning.test;

import java.io.File;

import java.util.concurrent.CountDownLatch;

public class ThreadDemo02

{

static int count;

static {

count = 0;

}

public static void main(String args[]) {

File file = new File("D:\\AA");

countNumberOfFolders(file);

long startTime = System.currentTimeMillis();

MyThread mt1 = new MyThread("线程1", file);

mt1.start();

try {

MyThread.latch.await();

}

catch (InterruptedException e) {

e.printStackTrace();

}

long usedTime = System.currentTimeMillis() - startTime;

System.out.println("耗时： " + usedTime + " ms");

}

/**

* 统计文件夹数量

* @param f

* @exception/throws [违例类型] [违例说明]

* @see [类、类#方法、类#成员]

*/

public static void countNumberOfFolders(File f) {

count++;

File[] files = f.listFiles();

if (files != null && files.length > 0) {

for (File file : files) {

if (file.isDirectory()) {

countNumberOfFolders(file);

}

}

}

}

}

class MyThread extends Thread

{

private String name;

private File file;

static CountDownLatch latch;

static {

latch = new CountDownLatch(ThreadDemo02.count);

}

public MyThread(String name, File file) {

this.name = name;

this.file = file;

}

@Override

public void run() {

File[] files = file.listFiles();

if (files != null && files.length > 0) {

for (File f : files) {

if (f.isDirectory()) {

new MyThread(f.getName(), f).start();

}

// 打印文件名不方便看最后的耗时打印，注释掉

// }else {

// System.out.println(Thread.currentThread().getName()+":"+f);

// }

}

}

System.out.println(name + " 运行结束");

latch.countDown();

}

}

结果如下：

http 运行结束

output 运行结束

dom 运行结束

compiler 运行结束

util 运行结束

耗时： 350 ms

可以看到确实是等到所有的线程执行结束后才进行的下一步。

如上 结题

本作品采用《CC 协议》，转载必须注明作者和本文链接