精华内容
下载资源
问答
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼这篇文章诺博源介绍了JAVA读取文件夹大小的单线程递归方式实例,有需要的朋友可以参考一下。具体的诺博源分享如下:package com.taobao.test;import java.io.File;public...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    这篇文章诺博源介绍了JAVA读取文件夹大小的单线程递归方式实例,有需要的朋友可以参考一下。

    具体的诺博源分享如下:

    package com.taobao.test;import java.io.File;public class TotalFileSizeSequential

    {

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    //

    递归方式 计算文件的大小

    private long getTotalSizeOfFilesInDir(final 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 += getTotalSizeOfFilesInDir(child);

    return total;

    }

    public static void main(final String[] args)

    {

    final long start = System.nanoTime();

    final long total = new TotalFileSizeSequential()

    .getTotalSizeOfFilesInDir(new File(fileName));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    展开全文
  • 这篇文章介绍了JAVA读取文件夹大小的几种方法实例,有需要的朋友可以参考一下。(一)单线程递归方式package com.taobao.test;import java.io.File;public class TotalFileSizeSequential {public static String ...

    这篇文章介绍了JAVA读取文件夹大小的几种方法实例,有需要的朋友可以参考一下。

    (一)单线程递归方式

    package com.taobao.test;

    import java.io.File;

    public class TotalFileSizeSequential {

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    // 递归方式 计算文件的大小

    private long getTotalSizeOfFilesInDir(final 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 += getTotalSizeOfFilesInDir(child);

    return total;

    }

    public static void main(final String[] args) {

    final long start = System.nanoTime();

    final long total = new TotalFileSizeSequential()

    .getTotalSizeOfFilesInDir(new File(fileName));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    (二)使用Executors.newFixedThreadPool和callable 多线程实现

    package com.taobao.test;

    import java.io.File;

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.List;

    import java.util.concurrent.Callable;

    import java.util.concurrent.ExecutionException;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.Future;

    import java.util.concurrent.TimeUnit;

    import java.util.concurrent.TimeoutException;

    public class ConcurrentTotalFileSize {

    public static final String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    class SubDirectoriesAndSize {

    final public long size;

    final public List subDirectories;

    public SubDirectoriesAndSize(final long totalSize,

    final List theSubDirs) {

    size = totalSize;

    subDirectories = Collections.unmodifiableList(theSubDirs);

    }

    }

    private SubDirectoriesAndSize getTotalAndSubDirs(final File file) {

    long total = 0;

    final List subDirectories = new ArrayList();

    if (file.isDirectory()) {

    final File[] children = file.listFiles();

    if (children != null)

    for (final File child : children) {

    if (child.isFile())

    total += child.length();

    else

    subDirectories.add(child);

    }

    }

    return new SubDirectoriesAndSize(total, subDirectories);

    }

    private long getTotalSizeOfFilesInDir(final File file)

    throws InterruptedException, ExecutionException, TimeoutException {

    final ExecutorService service = Executors.newFixedThreadPool(100);

    try {

    long total = 0;

    final List directories = new ArrayList();

    directories.add(file);

    while (!directories.isEmpty()) {

    final List> partialResults = new ArrayList>();

    for (final File directory : directories) {

    partialResults.add(service

    .submit(new Callable() {

    public SubDirectoriesAndSize call() {

    return getTotalAndSubDirs(directory);

    }

    }));

    }

    directories.clear();

    for (final Future partialResultFuture : partialResults) {

    final SubDirectoriesAndSize subDirectoriesAndSize = partialResultFuture

    .get(100, TimeUnit.SECONDS);

    directories.addAll(subDirectoriesAndSize.subDirectories);

    total += subDirectoriesAndSize.size;

    }

    }

    return total;

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args) throws InterruptedException,

    ExecutionException, TimeoutException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSize()

    .getTotalSizeOfFilesInDir(new File(fileName));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    (三)使用Executors.newFixedThreadPool和callable 多线程的另外一种实现

    package com.taobao.test;

    import java.io.File;

    import java.util.ArrayList;

    import java.util.List;

    import java.util.concurrent.Callable;

    import java.util.concurrent.ExecutionException;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.Future;

    import java.util.concurrent.TimeUnit;

    import java.util.concurrent.TimeoutException;

    public class NaivelyConcurrentTotalFileSize {

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    private long getTotalSizeOfFilesInDir(final ExecutorService service,

    final File file) throws InterruptedException, ExecutionException,

    TimeoutException {

    if (file.isFile())

    return file.length();

    long total = 0;

    final File[] children = file.listFiles();

    if (children != null) {

    final List> partialTotalFutures = new ArrayList>();

    for (final File child : children) {

    partialTotalFutures.add(service.submit(new Callable() {

    public Long call() throws InterruptedException,

    ExecutionException, TimeoutException {

    return getTotalSizeOfFilesInDir(service, child);

    }

    }));

    }

    for (final Future partialTotalFuture : partialTotalFutures)

    total += partialTotalFuture.get(100, TimeUnit.SECONDS);

    }

    return total;

    }

    private long getTotalSizeOfFile(final String fileName)

    throws InterruptedException, ExecutionException, TimeoutException {

    final ExecutorService service = Executors.newFixedThreadPool(100);

    try {

    return getTotalSizeOfFilesInDir(service, new File(fileName));

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args) throws InterruptedException,

    ExecutionException, TimeoutException {

    final long start = System.nanoTime();

    final long total = new NaivelyConcurrentTotalFileSize()

    .getTotalSizeOfFile(fileName);

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    (四)使用CountDownLatch和AtomicLong实现多线程下的并发控制

    package com.taobao.test;

    import java.io.File;

    import java.util.concurrent.CountDownLatch;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.TimeUnit;

    import java.util.concurrent.atomic.AtomicLong;

    public class ConcurrentTotalFileSizeWLatch {

    private ExecutorService service;

    final private AtomicLong pendingFileVisits = new AtomicLong();

    final private AtomicLong totalSize = new AtomicLong();

    final private CountDownLatch latch = new CountDownLatch(1);

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    private void updateTotalSizeOfFilesInDir(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 {

    pendingFileVisits.incrementAndGet();

    service.execute(new Runnable() {

    public void run() {

    updateTotalSizeOfFilesInDir(child);

    }

    });

    }

    }

    }

    }

    totalSize.addAndGet(fileSize);

    if (pendingFileVisits.decrementAndGet() == 0)

    latch.countDown();

    }

    private long getTotalSizeOfFile(final String fileName)

    throws InterruptedException {

    service = Executors.newFixedThreadPool(100);

    pendingFileVisits.incrementAndGet();

    try {

    updateTotalSizeOfFilesInDir(new File(fileName));

    latch.await(100, TimeUnit.SECONDS);

    return totalSize.longValue();

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args) throws InterruptedException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSizeWLatch()

    .getTotalSizeOfFile(fileName);

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    (五)使用BlockingQueue和AtomicLong的实现

    package com.taobao.test;

    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;

    public class ConcurrentTotalFileSizeWQueue {

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    private ExecutorService service;

    final private BlockingQueue fileSizes = new ArrayBlockingQueue(

    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();

    }

    private 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();

    }

    }

    public static void main(final String[] args) throws InterruptedException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSizeWQueue()

    .getTotalSizeOfFile(fileName);

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    (六)使用jdk7的ForkJoin来实现

    package com.taobao.test;

    import java.io.File;

    import java.util.ArrayList;

    import java.util.List;

    import java.util.concurrent.ForkJoinPool;

    import java.util.concurrent.ForkJoinTask;

    import java.util.concurrent.RecursiveTask;

    public class FileSize {

    private final static ForkJoinPool forkJoinPool = new ForkJoinPool();

    public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk";

    private static class FileSizeFinder extends RecursiveTask {

    final File file;

    public FileSizeFinder(final File theFile) {

    file = theFile;

    }

    @Override

    public Long compute() {

    long size = 0;

    if (file.isFile()) {

    size = file.length();

    } else {

    final File[] children = file.listFiles();

    if (children != null) {

    List> tasks = new ArrayList>();

    for (final File child : children) {

    if (child.isFile()) {

    size += child.length();

    } else {

    tasks.add(new FileSizeFinder(child));

    }

    }

    for (final ForkJoinTask task : invokeAll(tasks)) {

    size += task.join();

    }

    }

    }

    return size;

    }

    }

    public static void main(final String[] args) {

    final long start = System.nanoTime();

    final long total = forkJoinPool.invoke(new FileSizeFinder(new File("/home")));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start) / 1.0e9);

    }

    }

    展开全文
  • 场景为,给到一个硬盘上文件或文件夹,(当然文件夹时,多线程的优势才能越发体现出来),得到该文件或文件夹的大小和计算该结果所需要的时间。首先是单线程下的例子,这个可难不倒大家,代码如下:...

    场景为,给到一个硬盘上文件或文件夹,(当然文件夹时,多线程的优势才能越发体现出来),得到该文件或文件夹的大小和计算该结果所需要的时间。

    首先是单线程下的例子,这个可难不倒大家,代码如下:

    public class TotalFileSizeSequential {

    private long getTotalSizeOfFilesInDir(final 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 += getTotalSizeOfFilesInDir(child);

    return total;

    }

    public static void main(final String[] args) {

    final long start = System.nanoTime();

    final long total = new TotalFileSizeSequential()

    .getTotalSizeOfFilesInDir(new File("D:/idea_ws"));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start)/1.0e9);

    }

    }

    上述代码在我的机器上(win7,8g,i5)多次运行后的均值为:文件夹大小为276590351字节,即263M;耗时大概 0.25s

    Total Size: 276589881

    Time taken: 0.258706999

    至此,我们当然希望通过多线程扫描计算的方式,来更快的得到这个文件夹的大小,于是有个这个看似设计不错的,native版的代码:

    public class NaivelyConcurrentTotalFileSize {

    private long getTotalSizeOfFilesInDir(

    final ExecutorService service, final File file)

    throws InterruptedException, ExecutionException, TimeoutException {

    if (file.isFile()) return file.length();

    long total = 0;

    final File[] children = file.listFiles();

    if (children != null) {

    final List> partialTotalFutures =

    new ArrayList>();

    for(final File child : children) {

    partialTotalFutures.add(service.submit(new Callable() {

    public Long call() throws InterruptedException,

    ExecutionException, TimeoutException {

    return getTotalSizeOfFilesInDir(service, child);

    }

    }));

    }

    for(final Future partialTotalFuture : partialTotalFutures)

    total += partialTotalFuture.get(100, TimeUnit.SECONDS);

    }

    return total;

    }

    private long getTotalSizeOfFile(final String fileName)

    throws InterruptedException, ExecutionException, TimeoutException {

    final ExecutorService service = Executors.newFixedThreadPool(100);

    try {

    return getTotalSizeOfFilesInDir(service, new File(fileName));

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args)

    throws InterruptedException, ExecutionException, TimeoutException {

    final long start = System.nanoTime();

    final long total = new NaivelyConcurrentTotalFileSize()

    .getTotalSizeOfFile("D:/idea_ws");

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start)/1.0e9);

    }

    }

    额,运行的结果出乎意料,多次运行该多线程代码,去扫描计算这个263M的文件夹时,仅有几次能运行成功,大部分时候,都是死锁,导致程序崩溃,根本无法计算文件夹大小。

    这段程序在getTotalSizeOfFilesInDir(final ExecutorService service, final File file) 方法中,有阻塞线程池的操作。每当扫描到一个子目录的时候,它就将该任务调度给其他的线程。这个逻辑看上去没有错,一旦它调度完了所有任务,该函数就等待任何一个任务的响应。即是代码中的 total += partialTotalFuture.get(100, TimeUnit.SECONDS);这一行。

    当然,当给到扫描的目录不是很深,文件不很多时,这样做确实能很快的得到结果,否则,就会在该行卡主,一直等待响应,若是没有我们设置的100的超时操作,这将演变成一种潜在的“线程诱发型死锁(Pool Include DeadLock)”            此时,我们就要考虑如何改善这段代码了,目标是:计算各子目录大小的任务分配给不同线程,当我们等待其他任务响应时,又不会占住当前的主调线程(避免死锁)。

    下面,是第一种解决方案:每个任务都返回给定目录的直接子目录列表,而不是去返回计算的大小。这样的好处是,使线程被堵住的时间不会超过扫描给定目录的直接子目录的时间。在返回直接子目录的同时,计算出目录中的文件的大小一并返回。

    那么,第一个修复版本的代码如下:

    public class ConcurrentTotalFileSize {

    class SubDirectoriesAndSize {

    final public long size;

    final public List subDirectories;

    public SubDirectoriesAndSize(

    final long totalSize, final List theSubDirs) {

    size = totalSize;

    subDirectories = Collections.unmodifiableList(theSubDirs);

    }

    }

    private SubDirectoriesAndSize getTotalAndSubDirs(final File file) {

    long total = 0;

    /*

    list的作用:

    1.先存放入参file,根据file,得到它下面的SubDirectoriesAndSize对象,即总的文件大小和总的文件夹的ls。根据getTotalSubDirs(final File file)获取

    2.清空上一步的入参file,用于存放SubDirectoriesAndSize.dirs

    */

    final List subDirectories = new ArrayList();

    if(file.isDirectory()) {

    final File[] children = file.listFiles();

    if (children != null)

    for(final File child : children) {

    if (child.isFile())

    total += child.length();

    else

    subDirectories.add(child);

    }

    }

    return new SubDirectoriesAndSize(total, subDirectories);

    }

    private long getTotalSizeOfFilesInDir(final File file)

    throws InterruptedException, ExecutionException, TimeoutException {

    final ExecutorService service = Executors.newFixedThreadPool(100);

    try {

    long total = 0;

    final List directories = new ArrayList();

    directories.add(file);

    while(!directories.isEmpty()) {

    final List> partialResults =

    new ArrayList>();

    for(final File directory : directories) {

    partialResults.add(

    service.submit(new Callable() {

    public SubDirectoriesAndSize call() {

    return getTotalAndSubDirs(directory);

    }

    }));

    }

    directories.clear();

    for(final Future partialResultFuture :

    partialResults) {

    final SubDirectoriesAndSize subDirectoriesAndSize =

    partialResultFuture.get(100, TimeUnit.SECONDS);

    directories.addAll(subDirectoriesAndSize.subDirectories);

    total += subDirectoriesAndSize.size;

    }

    }

    return total;

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args)

    throws InterruptedException, ExecutionException, TimeoutException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSize()

    .getTotalSizeOfFilesInDir(new File("D:/idea_ws"));

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start)/1.0e9);

    }

    }            以上代码多次运行后的结果为:

    Total Size: 276592101

    Time taken: 0.124100452

    比起单线程版本,速度基本提升了一倍的样子。到此,我们这个任务就完成了么?不,难道你不觉得上面这个设计,虽然说起来简单,但是实现起来却并不那么容易么?

    我们不仅需要设计一个用于保存计算任务的返回结果的不变的子类,而且还要花心思去设计如何不断的分派任务以及协调处理任务的返回结果。所以,即使我们这个设计提高了性能,却引入了相当的复杂性。

    所以,我们下面将会引入CountDownLatch辅助实现线程的设计和协作。上面的设计中,我们引入了Future,我们通过它获取任务的执行结果,同时,Future也隐含的帮我们完成了一些任务/线程之间的协调工作,我们因此不用考虑线程切换和并行中可能发现的一些问题。但是,大家知道,Future是需要返回值的,假使我们的任务没有返回值的话,Future就不太适合出现在我们的代码中,并且作为线程间的协作工具了。此时,我们会考虑到CountDownLatch作为替代。

    下面,我们将使用到CountDownLatch去做协调,在扫描到一个文件时,线程不在能够通过Future去接受一个计算的返回结果,而是去更新一个AtomicLong类型的共享变量totalSize。AtomicLong提供了更新并取回一个简单long类型的变量的线程安全的方法。此外,我们还会有个AtomicLong类型的变量pendingFileVisits,用于保存当前等待访问的文件或子目录的数量。而当该值为0时,我们就通过countDown()来释放线程闩。

    public class ConcurrentTotalFileSizeWLatch {

    private ExecutorService service;

    //用于计算待扫描的文件/子文件夹的个数

    final private AtomicLong pendingFileVisits = new AtomicLong();

    final private AtomicLong totalSize = new AtomicLong();

    //定义一个锁存器,给定计数初始化的 CountDownLatch的个数是1个

    final private CountDownLatch latch = new CountDownLatch(1);

    private void updateTotalSizeOfFilesInDir(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 {

    pendingFileVisits.incrementAndGet();

    service.execute(new Runnable() {

    public void run() { updateTotalSizeOfFilesInDir(child); }

    });

    }

    }

    }

    }

    totalSize.addAndGet(fileSize);

    //递减锁存器的计数,如果计数到达零,则释放所有等待的线程。

    if(pendingFileVisits.decrementAndGet() == 0) latch.countDown();

    }

    private long getTotalSizeOfFile(final String fileName)

    throws InterruptedException {

    service  = Executors.newFixedThreadPool(100);

    pendingFileVisits.incrementAndGet();

    try {

    updateTotalSizeOfFilesInDir(new File(fileName));

    // 使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断或超出了指定的等待时间。

    latch.await(100, TimeUnit.SECONDS);

    return totalSize.longValue();

    } finally {

    service.shutdown();

    }

    }

    public static void main(final String[] args) throws InterruptedException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSizeWLatch()

    .getTotalSizeOfFile("D:/idea_ws");

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start)/1.0e9);

    }

    }

    这个版本的代码比较上一个版本,简洁了很多,下面我们看看运行的结果:

    Total Size: 276592105

    Time taken: 0.114999062

    结果比较上一个版本,性能上差不多。然而,即使简洁,高性能,但是这个版本的代码存在着访问共享可变变量的风险。我们将在后面研究,如何二者兼得的方法。

    上面2个版本的代码中,我们通过Future和AtomicLong来实现数据的交换功能。当任务完成时能获取返回值时,Future就能派上用场,而AtomicLong的线程安全的原子操作对处理单个共享数据的值来说,是非常有用的。

    如果,只是想在两个线程间交换数据,我们可以用Exchanger类。它可以看做一个同步点,两个线程在改同步点上,可以线程安全的方式互换数据,如果两个线程的运行速度不一样,则运行较快的会被阻塞,直到慢的线程赶到同步点时,才能开始数据的互换。

    所以,如果想在线程间互发多组数据,则BlockingQueue接口可以派上用场。队列想必大家都比较熟悉了,队列没用空间,插入时会被阻塞;队列里没有可用数据,删除时会被阻塞。若想要插入和删除操作一一对应,可以使用SynchronousQueue类。该类的作用是本线程的每一个插入操作与其他线程相应的删除操作相匹配,以完成类似的手递手形式的数据传输。如果希望数据根据某种优先级在队列中上下浮动,则可以使用PriorityBlockingQueue。另外,如果只是要一个简单的阻塞队列,我们可以用链表的实现LinkedBlockingQueue或者数组的实现ArrayBlockingQueue。

    第3版的代码如下:

    public class ConcurrentTotalFileSizeWQueue {

    private ExecutorService service;

    //定义队列,存放每个线程得到的fileSize

    final private BlockingQueue fileSizes =

    new ArrayBlockingQueue(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();

    }

    private 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();

    }

    }

    public static void main(final String[] args) throws InterruptedException {

    final long start = System.nanoTime();

    final long total = new ConcurrentTotalFileSizeWQueue()

    .getTotalSizeOfFile("D:/idea_ws");

    final long end = System.nanoTime();

    System.out.println("Total Size: " + total);

    System.out.println("Time taken: " + (end - start)/1.0e9);

    }

    }

    这个版本的运行结果如下:

    Total Size: 276591906

    Time taken: 0.124069344

    这一版的性能与之前一版相仿,但是代码简化方面又有提升了,主要归功与阻塞队列帮我们完成了线程之间的数据交换和同步的操作。由于oschina博客的字数限制,之后一篇文章,将利用java7引入的新的api来进一步改进上面的方案。

    展开全文
  • java多线程读取多个文件的方法发布于 2020-6-19|复制链接摘记: 本文实例为大家分享了java多线程读取多个文件的具体代码,供大家参考,具体内容如下工具类代码如下:```javaimport java.io.*;import java.util.List;...

    java多线程读取多个文件的方法

    发布于 2020-6-19|

    复制链接

    摘记: 本文实例为大家分享了java多线程读取多个文件的具体代码,供大家参考,具体内容如下工具类代码如下:

    ```java

    import java.io.*;

    import java.util.List;

    import java.util.concurrent.CountDownLatch;

    /**

    * 多线程读取多个文件

    */

    ..

    本文实例为大家分享了java多线程读取多个文件的具体代码,供大家参考,具体内容如下工具类代码如下:

    ```java

    import java.io.*;

    import java.util.List;

    import java.util.concurrent.CountDownLatch;

    /**

    * 多线程读取多个文件

    */

    public class FileThread extends Thread{

    private final CountDownLatch countDownLatch = new CountDownLatch(10);

    private int fileIndex;

    private List filelist;

    private String filepath = "D:\\LocalFtpServer\\data20181229\\";

    private String movepath = "D:\\LocalFtpServer\\data20181229_01\\";

    public int getFileIndex() {

    return fileIndex;

    }

    public void setFileIndex(int fileIndex) {

    this.fileIndex = fileIndex;

    }

    public List getFilelist() {

    return filelist;

    }

    public void setFilelist(List filelist) {

    this.filelist = filelist;

    }

    @Override

    public void run() {

    for (int i = 0; i 调用测试:

    ```java

    public static void main(String[] args) throws IOException {

    String filepath = "D:\\LocalFtpServer\\data20181229\\";

    File file = new File(filepath);

    //读取目录下所有文件

    String[] filelist = file.list();

    List fList=new ArrayList();

    展开全文
  • Java监控文件夹变化1. 线程轮询扫描优点:纯java实现,完美跨平台。缺点:监听文件较多时,需要扫描的量太;响应不是非常及时,依赖于扫描间隔时间。2. 文件钩子优点:事件驱动方式,无目录扫描。缺点:跟平台相关...
  • 多线程自动监视并扫描指定文件夹中的文件变化 下载源代码 [url]http://www.java3z.com/cwbwebhome/article/article5/5843.html?id=1607[/url] 〖 作者:cctaiyang 〗〖 大小:5k 〗〖 发布日期:2007-09-...
  • * 获取某个目录下所有文件名,以文件夹分组 * * @param pathStr * @return */ public static List<Map> getAllFilePathGroupFolder(String pathStr) { System.out.println("开始扫描:"+ pathStr...
  • 1. 线程轮询扫描优点:纯java实现,完美跨平台。缺点:监听文件较多时,需要扫描的量太;响应不是非常及时,依赖于扫描间隔时间。2. 文件钩子优点:事件驱动方式,无目录扫描。缺点:跟平台相关Jnotify开发包是个...
  • Java监控文件夹变化

    千次阅读 2015-01-02 14:32:39
    缺点:监听文件较多时,需要扫描的量太;响应不是非常及时,依赖于扫描间隔时间。  2. 文件钩子  优点:事件驱动方式,无目录扫描。  缺点:跟平台相关  Jnotify开发包是个不错的文件钩子库,使用方式...
  • 需求描述:从键盘接收一个文件夹路径,获得该文件夹大小并输出到控制台。 代码实现: import java.io.File; import java.util.Scanner; public class Demo934 { public static void main(String[] args) { //...
  • java 监控文件夹变化(钩子文件)

    千次阅读 2016-05-18 13:30:28
    缺点:监听文件较多时,需要扫描的量太;响应不是非常及时,依赖于扫描间隔时间。  2. 文件钩子  优点:事件驱动方式,无目录扫描。  缺点:跟平台相关  Jnotify开发包是个不错的文件钩子库,使用方式如下:...
  • 最近想自己写个Android音乐播放器练手,首先遇到的问题就是如何将手机...下面是我整理的一种写法,使用递归扫描指定文件夹的文件并输出路径。 /** * 读取某个文件下的所有文件 */ public boolean readfile(Strin
  • 1. 扫描指定文件夹 2. 使用MAP<String,List<String,File>>记录全部文件,是文件记录MD5值和路径,是文件夹递归调用。MD5作为Key,文件集合作为value 上菜。 /** * 获取重复的文件 * @param ...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历,...
  • 在接的一个外包项目里面:有一个二维码扫描仪的二次开发的项目,在这里面有个问题就是需要将一个比较文件夹里面的所有内容复制到另外一个文件夹中,由于文件夹里面的内容还比较多,所以需要一点高效的方法。...
  • 先下载20.0版本的fortify,下载地址:http://www.pc6.com/softview/SoftView_837967.html下载后傻瓜式安装安装完成后,打开Audit ...不知道的话就选Advanced Scan)选择代码文件夹,如果代码文件很,建议拆开一个...
  • 小文件很快,但是文件就很满了,主要原因就是在缓冲数组扩容的地方的瓶颈 import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStre...
  • 该插件会生成Java常量类,并在ESH_INF文件夹文件中定义所有命名。 为什么? 如果内容很多,因为很难自己编写此类。 此外,XML文件应处于领先地位,并且您的代码库始终保持同步。 如何? 该插件将扫描给定输入目录...
  • Python 扫描监控本地文件夹并进行超大文件分块上传1. 监控本地文件夹2. 利用sftp连接远程服务器,并上传目录或者文件;3. 超大文件先压缩,后上传完成在解压;4. 超大文件直接分块上传,完成后合并;参考: Python...
  • fortify代码扫描使用教程

    万次阅读 热门讨论 2018-09-13 16:08:06
    配置信息:HP Fortify SCA and Applications 4.10+WIN7(64位家庭版) 打开fortify的工作台,选择Advanced Scan...选择代码文件夹,如果代码文件很,建议拆开一个文件夹一个文件夹扫描 确定后,弹出通知框...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历...
  • java 多张jpg合成tif后避免tif文件过的方法

    千次阅读 热门讨论 2018-04-19 17:13:31
    这几天突然有个需求要求把之前的通过扫描仪扫出来的jpg图片给合成一个tif文件,乍一看这个需求还是没啥问题的,于是乎直接上网找一个方法下来就好啦,百度“多张jpg合成tif”得到如下方法: /** * 合并成一个...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历,...
  • 而是直接放在java文件夹下,那么,dayApplication.java中的@EnableAutoConfiguration @ComponentScan这两个注解会将项目中的jar包中的每一个类都进行扫描,从而进行自动配置,这样会对springboot程序造成非常的...
  • Java目录监视器源程序 9个目标文件 内容索引:JAVA源码,综合应用,目录监视 用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java...

空空如也

空空如也

1 2 3 4
收藏数 69
精华内容 27
关键字:

java扫描大文件夹

java 订阅