计算文件夹大小

1.单线程递归获取文件夹大小

public static long getDirSize(File file) {
if (file.isFile())
return file.length();
final File[] children = file.listFiles();
long total = 0;
if (children != null)
for (final File child : children)
total += getDirSize(child);
return total;
}

2.多线程BlockingQueue

import java.io.File;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* Created by shijack on 2016/7/8.
* <p>Attention: when the dir size is larger than 1G the speed can faster than in only one thread!</p>
*/

public class ConcurrentDirSizeCountUtil {

private ExecutorService service;
final private BlockingQueue<Long> fileSizes = new ArrayBlockingQueue<Long>(
500);
final AtomicLong pendingFileVisits = new AtomicLong();

private void startExploreDir(final File file) {
pendingFileVisits.incrementAndGet();
service.execute(new Runnable() {
public void run() {
exploreDir(file);
}
});
}

private void exploreDir(final File file) {
long fileSize = 0;
if (file.isFile())
fileSize = file.length();
else {
final File[] children = file.listFiles();
if (children != null)
for (final File child : children) {
if (child.isFile())
fileSize += child.length();
else {
startExploreDir(child);
}
}
}
try {
fileSizes.put(fileSize);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
pendingFileVisits.decrementAndGet();
}

public long getTotalSizeOfFile(final String fileName) throws InterruptedException {
service = Executors.newFixedThreadPool(100);
try {
startExploreDir(new File(fileName));
long totalSize = 0;
while (pendingFileVisits.get() > 0 || fileSizes.size() > 0) {
final Long size = fileSizes.poll(10, TimeUnit.SECONDS);
totalSize += size;
}
return totalSize;
} finally {
service.shutdown();
}
}

}

3.多线程Build.VERSION_CODES.LOLLIPOP之后使用ForkJoinTask

import android.annotation.TargetApi;
import android.os.Build;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeoutException;

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class FileSize {
private final static ForkJoinPool forkJoinPool = new ForkJoinPool();

private static class FileSizeFinder extends RecursiveTask<Long> {
File file;
public FileSizeFinder(File file){
this.file = file;
}

@Override
protected Long compute() {
// TODO Auto-generated method stub
long size = 0;
if(file.isFile()){
return file.length();
}else{
File[] children = file.listFiles();
if(children != null){
List<ForkJoinTask<Long>> tasks = new ArrayList<ForkJoinTask<Long>>();
for(File child:children){
if(child.isFile()){
size += child.length();
}else{
tasks.add(new FileSizeFinder(child));
}
}

for(ForkJoinTask<Long> task:invokeAll(tasks)){ //等待所有的子任务完成之后才会执行下一步循环操作。在任务被阻塞时，
//其他程序也可以去帮忙完成其他任务
size += task.join();
}
}
}
return size;
}
}

public static void main(final String[] args)
throws InterruptedException,ExecutionException,TimeoutException {
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
System.out.println("get the output--->" + str);
final long start = System.nanoTime();
final long total = forkJoinPool.invoke(new FileSizeFinder(new File(str)));
final long end = System.nanoTime();
System.out.println("Total Size: " + total);
System.out.println("Time taken: " + (end-start)/1.0e9);
}
}

注意：