从静态代码扫描引擎PMD源码学习-多线程任务模型和File过滤设计

不知不觉在工作中研究PMD并定制规则已经4个月左右了。其实PMD有许多值得我学习的源码，不过出于时间并不曾动笔。今天简单记录总结一下PMD的多线程和File过滤设计的源码。

public class MultiThreadProcessor extends AbstractPMDProcessor {

    private ExecutorService executor;
    private CompletionService<Report> completionService;
    private List<Future<Report>> tasks = new ArrayList<>();

    public MultiThreadProcessor(final PMDConfiguration configuration) {
        super(configuration);

        executor = Executors.newFixedThreadPool(configuration.getThreads(), new PmdThreadFactory());
        completionService = new ExecutorCompletionService<>(executor);
    }

    @Override
    protected void runAnalysis(PmdRunnable runnable) {
        // multi-threaded execution, dispatch analysis to worker threads
        tasks.add(completionService.submit(runnable));
    }

    @Override
    protected void collectReports(List<Renderer> renderers) {
        // Collect result analysis, waiting for termination if needed
        try {
            for (int i = 0; i < tasks.size(); i++) {
                final Report report = completionService.take().get();
                super.renderReports(renderers, report);
            }
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException ee) {
            Throwable t = ee.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else if (t instanceof Error) {
                throw (Error) t;
            } else {
                throw new IllegalStateException("PmdRunnable exception", t);
            }
        } finally {
            executor.shutdownNow();
        }
    }
}

这是MultiThreadProcessor，多线程执行类。

关键类是CompletionService，PMD使用实现了Callable接口的PMDRunnable类来封装线程的具体运行，在这个类的call方法里进行重写。今天的核心不是call里的代码，核心是这种任务式提交的多线程操作的常见写法。也就是结合CompletionService。

我们知道，如果实现了Callable接口，那么使用者是想获得结果的，而结果是Future对象，PMD代码中的Report就是call的返回，使用Future来泛型封装。

CompletionService内部维护一个BlockQuene队列，通过ExecutorCompletionService<>(executor)来传入一个executor，也就是一个线程池。

这里使用jdk自带的Executors.newFixedThreadPool来创建固定大小的线程池，也就是上限啦。

如果自己使用callable接口来向池子submit，返回future需要自己管理，而CompletionService则可以完美管理，应当每次都使用该类。

通过completionService.submit(runnable)，提交callable实例，获得Future对象，我们通过一个集合List存储，但实际上我们后续并不真正要遍历使用每一个Future。

注意，submit是让线程开始启动。

线程运行后，如何拿结果？

使用completionService.take().get();获得call方法最终返回的结果类对象。
completionService.take就是获得Future对象,但这里已经是异步操作.
通过submit启动了一个线程,take操作会获得先运行完的线程的结果Future实例,这是这个服务类内部代码所实现的.
通过get获得Future封装的对象report
至此,一连串标准操作,非常舒服.
---------------------------------------------------------------
接下来是,文件的Filter篇:
最近在给PMD增加exclude的功能.发现他的FileUtil类里写了以后要做exclude功能的注释...结果6.x版本也还没实现啊..然后我做了半天左右实现好了.(参数传入)

实际上PMD的文件过滤是基于Filter实现,也和FilenameFilter有关.
核心来自于jdk的File.list(FilenameFilter filter)

public static List<DataSource> collectFiles(String fileLocations, FilenameFilter filenameFilter) {
        List<DataSource> dataSources = new ArrayList<>();
        for (String fileLocation : fileLocations.split(",")) {
            collect(dataSources, fileLocation, filenameFilter);
        }
        return dataSources;
    }

    private static List<DataSource> collect(List<DataSource> dataSources, String fileLocation,
            FilenameFilter filenameFilter) {
        File file = new File(fileLocation);
        if (!file.exists()) {
            throw new RuntimeException("File " + file.getName() + " doesn't exist");
        }
        if (!file.isDirectory()) {
            if (fileLocation.endsWith(".zip") || fileLocation.endsWith(".jar")) {
                ZipFile zipFile;
                try {
                    zipFile = new ZipFile(fileLocation);
                    Enumeration<? extends ZipEntry> e = zipFile.entries();
                    while (e.hasMoreElements()) {
                        ZipEntry zipEntry = e.nextElement();
                        if (filenameFilter.accept(null, zipEntry.getName())) {
                            dataSources.add(new ZipDataSource(zipFile, zipEntry));
                        }
                    }
                } catch (IOException ze) {
                    throw new RuntimeException("Archive file " + file.getName() + " can't be opened");
                }
            } else {
                dataSources.add(new FileDataSource(file));
            }
        } else {
            // Match files, or directories which are not excluded.
            // FUTURE Make the excluded directories be some configurable option
            Filter<File> filter = new OrFilter<>(Filters.toFileFilter(filenameFilter),
                    new AndFilter<>(Filters.getDirectoryFilter(), Filters.toNormalizedFileFilter(
                            Filters.buildRegexFilterExcludeOverInclude(null, Collections.singletonList("SCCS")))));
            FileFinder finder = new FileFinder();
            List<File> files = finder.findFilesFrom(file, Filters.toFilenameFilter(filter), true);
            for (File f : files) {
                dataSources.add(new FileDataSource(f));
            }
        }
        return dataSources;
    }

这是PMD来collect的核心代码.dataSource其实就是一个File再次封装的类.

collectFiles这个方法就是,传入source路径,一个目录,一个文件路径皆可.
再传入一个过滤类FilenameFilter,在PMD当前实现里是直接传入基于Language代码语言来做的后缀扩展名extension过滤FilenameFilter,
最后是传入一个集合,就是做封装的盒子.
因为路径参数是逗号分隔的,所以先做遍历,然后对每个路径进行调用collect方法.
接下来是核心,collect传入一个FilenameFilter,然后过滤这个路径下的File.
其实也是简单的实现.
然后再回到,如果我想增加一个过滤目录的功能怎么办?看似我可以在主代码里传入一个exclude的FilenameFilter,实际上它这个collect返回了dataSource,很不利于再次分析.
也就是说,这块代码其实没什么向后兼容的可能了.
既然PMD的作者,写死了,那我也就稍做修改.
Filter的精髓其实是OrFilter和AndFilter这种类,理解也很简单,一个OrFilter里维护一个Filter的List,只要有一个返回true,那就返回true
AndFilter里维护着Filter的List,全部返回true才会返回true.我记得apache commons里也有类似的io的file的Filter类.
以后如果想自己做这种功能,也可以用apache的包.
其实Filter也很简单,就讲这么多.