Fork/Join框架介绍III 【在一个文件夹及其子文件夹中来搜索带有指定扩展名的文件】

Fork/Join异步

在ForkJoinPool中执行 ForkJoinTask时，可以采用同步或异步方式。当采用同步方式执行时，发送任务给Fork/Join线程池的方法直到任务执行完成后才会返回结果。而采用异步方式执行时，发送任务给执行器的方法将立即返回结果，但是任务仍能够继续执行。

需要明白这两种方式在执行任务时的一个很大的区别。当采用同步方式，调用这些方法（比如，invokeAll()方法）时，任务被挂起，直到任务被发送到Fork/Join线程池中执行完成。这种方式允许ForkJoinPool类采用工作窃取算法（Work-StealingAlgorithm）来分配一个新任务给在执行休眠任务的工作者线程（WorkerThread）。相反，当采用异步方法（比如，fork()方法）时，任务将继续执行，因此ForkJoinPool类无法使用工作窃取算法来提升应用程序的性能。在这个示例中，只有调用join()或get()方法来等待任务的结束时，ForkJoinPool类才可以使用工作窃取算法。

代码实例

ForkJoinPool和ForkJoinTask类所提供的异步方法来管理任务。我们将实现一个程序：
在一个文件夹及其子文件夹中来搜索带有指定扩展名的文件。
ForkJoinTask类将实现处理这个文件夹的内容。而对于这个文件夹中的每一个子文件，任务将以异步的方式发送一个新的任务给ForkJoinPool类。对于每个文件夹中的文件，任务将检查任务文件的扩展名，如果符合条件就将其增加到结果列表中。

Main.java

package com.packtpub.java7.concurrency.chapter5.recipe03.core;

import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;

import com.packtpub.java7.concurrency.chapter5.recipe03.task.FolderProcessor;

public class Main {

    /**
     * Main method of the example
    */
    public static void main(String[] args) {
        // Create the pool
        ForkJoinPool pool=new ForkJoinPool();

        // Create three FolderProcessor tasks for three diferent folders
        FolderProcessor system=new FolderProcessor("C:\\Windows", "log");
        FolderProcessor apps=new FolderProcessor("C:\\Program Files","log");
        FolderProcessor documents=new FolderProcessor("C:\\Documents And Settings","log");

        // Execute the three tasks in the pool
        pool.execute(system);
        pool.execute(apps);
        pool.execute(documents);

        // Write statistics of the pool until the three tasks end
        do {
            System.out.printf("******************************************\n");
            System.out.printf("Main: Parallelism: %d\n",pool.getParallelism());
            System.out.printf("Main: Active Threads: %d\n",pool.getActiveThreadCount());
            System.out.printf("Main: Task Count: %d\n",pool.getQueuedTaskCount());
            System.out.printf("Main: Steal Count: %d\n",pool.getStealCount());
            System.out.printf("******************************************\n");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } while ((!system.isDone())||(!apps.isDone())||(!documents.isDone()));

        // Shutdown the pool
        pool.shutdown();

        // Write the number of results calculate by each task
        List<String> results;

        results=system.join();
        System.out.printf("System: %d files found.\n",results.size());

        results=apps.join();
        System.out.printf("Apps: %d files found.\n",results.size());

        results=documents.join();
        System.out.printf("Documents: %d files found.\n",results.size());


    }

}

FolderProcessor.java

package com.packtpub.java7.concurrency.chapter5.recipe03.task;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.RecursiveTask;

/**
 * Task that process a folder. Throw a new FolderProcesor task for each
 * subfolder. For each file in the folder, it checks if the file has the extension
 * it's looking for. If it's the case, it add the file name to the list of results.
 *
 */
public class FolderProcessor extends RecursiveTask<List<String>> {

    /**
     * Serial Version of the class. You have to add it because the 
     * ForkJoinTask class implements the Serializable interfaces
     */
    private static final long serialVersionUID = 1L;

    /**
     * Path of the folder this task is going to process
     */
    private String path;

    /**
     * Extension of the file the task is looking for
     */
    private String extension;

    /**
     * Constructor of the class
     * @param path Path of the folder this task is going to process
     * @param extension Extension of the files this task is looking for
     */
    public FolderProcessor (String path, String extension) {
        this.path=path;
        this.extension=extension;
    }

    /**
     * Main method of the task. It throws an additional FolderProcessor task
     * for each folder in this folder. For each file in the folder, it compare
     * its extension with the extension it's looking for. If they are equals, it
     * add the full path of the file to the list of results
     */
    @Override
    protected List<String> compute() {
        List<String> list=new ArrayList<>();
        List<FolderProcessor> tasks=new ArrayList<>();

        File file=new File(path);
        File content[] = file.listFiles();
        if (content != null) {
            for (int i = 0; i < content.length; i++) {
                if (content[i].isDirectory()) {
                    // If is a directory, process it. Execute a new Task
                    FolderProcessor task=new FolderProcessor(content[i].getAbsolutePath(), extension);
                    task.fork();
                    tasks.add(task);
                } else {
                    // If is a file, process it. Compare the extension of the file and the extension
                    // it's looking for
                    if (checkFile(content[i].getName())){
                        list.add(content[i].getAbsolutePath());
                    }
                }
            }

            // If the number of tasks thrown by this tasks is bigger than 50, we write a message
            if (tasks.size()>50) {
                System.out.printf("%s: %d tasks ran.\n",file.getAbsolutePath(),tasks.size());
            }

            // Include the results of the tasks
            addResultsFromTasks(list,tasks);
        }
        return list;
    }

    /**
     * Add the results of the tasks thrown by this task to the list this
     * task will return. Use the join() method to wait for the finalization of
     * the tasks
     * @param list List of results
     * @param tasks List of tasks
     */
    private void addResultsFromTasks(List<String> list,
            List<FolderProcessor> tasks) {
        for (FolderProcessor item: tasks) {
            list.addAll(item.join());
        }
    }

    /**
     * Checks if a name of a file has the extension the task is looking for
     * @param name name of the file
     * @return true if the name has the extension or false otherwise
     */
    private boolean checkFile(String name) {
        if (name.endsWith(extension)) {
            return true;
        }
        return false;
    }


}

运行结果

---

Main: Parallelism: 4
Main: Active Threads: 4
C:\Windows: 59 tasks ran.
Main: Task Count: 91
Main: Steal Count: 0

---

C:\Windows\assembly\GAC_MSIL: 294 tasks ran.
C:\Windows\assembly\NativeImages_v2.0.50727_32: 122 tasks ran.
C:\Windows\assembly\NativeImages_v2.0.50727_64: 114 tasks ran.
C:\Windows\assembly\NativeImages_v4.0.30319_32: 147 tasks ran.
C:\Windows\assembly\NativeImages_v4.0.30319_64: 141 tasks ran.
C:\Windows\Microsoft.NET\assembly\GAC_MSIL: 193 tasks ran.

---

Main: Parallelism: 4
Main: Active Threads: 38
Main: Task Count: 1030
Main: Steal Count: 615

---

C:\Windows\SysWOW64: 88 tasks ran.
C:\Windows\System32: 91 tasks ran.

---

Main: Parallelism: 4
Main: Active Threads: 24
Main: Task Count: 521
Main: Steal Count: 1362

---

C:\Windows\System32\DriverStore\FileRepository: 264 tasks ran.

---

Main: Parallelism: 4
Main: Active Threads: 9
Main: Task Count: 1852
Main: Steal Count: 2113

---

---

Main: Parallelism: 4
Main: Active Threads: 4
Main: Task Count: 1341
Main: Steal Count: 2268

---

---

Main: Parallelism: 4
Main: Active Threads: 4
Main: Task Count: 1313
Main: Steal Count: 4623

---

C:\Windows\winsxs: 13303 tasks ran.

---

Main: Parallelism: 4
Main: Active Threads: 5
Main: Task Count: 870
Main: Steal Count: 4623

---

---

Main: Parallelism: 4
Main: Active Threads: 2
Main: Task Count: 0
Main: Steal Count: 13058

---

---

Main: Parallelism: 4
Main: Active Threads: 2
Main: Task Count: 0
Main: Steal Count: 13058

---

System: 21 files found.
Apps: 6 files found.
Documents: 0 files found.

工作原理

这个范例的重点在于FolderProcessor类。每一个任务处理一个文件夹中的内容。文件夹中的内容有以下两种类型的元素：

文件；
其他文件夹。
如果主任务发现一个文件夹，它将创建另一个Task对象来处理这个文件夹，调用fork()方法把这个新对象发送到线程池中。fork()方法发送任务到线程池时，如果线程池中有空闲的工作者线程（WorkerThread）或者将创建一个新的线程，那么开始执行这个任务，fork()方法会立即返回，因此，主任务可以继续处理文件夹里的其他内容。对于每一个文件，任务开始比较它的文件扩展名，如果与要搜索的扩展名相同，那么将文件的完整路径增加到结果列表中。

一旦主任务处理完指定文件夹里的所有内容，它将调用join()方法等待发送到线程池中的所有子任务执行完成。join()方法在主任务中被调用，然后等待任务执行结束，并通过compute()方法返回值。主任务将所有的子任务结果进行合并，这些子任务发送到线程池中时带有自己的结果列表，然后通过调用compute()方法返回这个列表并作为主任务的返回值。

ForkJoinPool类也允许以异步的方式执行任务。调用execute()方法发送3个初始任务到线程池中。在Main主类中，调用shutdown()方法结束线程池，并在控制台输出线程池中任务的状态及其变化的过程。ForkJoinPool类包含了多个方法可以实现这个目的。

扩展

本范例使用join()方法来等待任务的结束，然后获取它们的结果。也可以使用get()方法以下的两个版本来完成这个目的。

• get()：如果ForkJoinTask类执行结束，或者一直等到结束，那么
• get()方法的这个版本则返回由compute()方法返回的结果。
• get(long timeout, TimeUnit unit)：如果任务的结果未准备好，那么get()方法的 这个版本将等待指定的时间。如果超过指定的时间了，任务的结果仍未准备好，那么这 个方法将返回 null值。

TimeUnit是一个枚举类，有如下的常量：DAYS、HOURS、MICROSECONDS、MILLISECONDS、MINUTES、NANOSECONDS和SECONDS。

get()方法和join()方法还存在两个主要的区别：

• join()方法不能被中断，如果中断调用join()方法的线程，方法将抛出InterruptedException异常；
• 如果任务抛出任何运行时异常，那么 get()方法将返回ExecutionException异常，但是join()方法将返回RuntimeException异常。

转自：http://ifeve.com/java7-concurrency-cookbook-4/