阻塞队列(ArrayBlockingQueue)：搜索目录下所有文件包含的关键字

package thread.concurrent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ArrayBlockingQueueTest {
    private static final Logger logger = LoggerFactory.getLogger(ArrayBlockingQueueTest.class);

    private static final int FILE_QUEUE_SIZE = 10;
    private static final int SEARCH_THREADS = 100;
    // 标记文件，该文件最先放在阻塞队列中。当take到这个文件时，说明阻塞队列里已经没有文件了
    private static final File DUMMY = new File("");

    private static BlockingQueue<File> filesQueue = new ArrayBlockingQueue<>(FILE_QUEUE_SIZE);

    /**
     * 将目录下的文件放入到阻塞队列中
     *
     * @param directory 要搜索的目录
     * @throws InterruptedException 抛出异常
     */
    private static void putIntoQueue(File directory) throws InterruptedException {
        File[] files = directory.listFiles();
        if (files == null) {
            logger.info("目录找不到");
            return;
        }

        for (File file : files) {
            if (file.isDirectory())
                putIntoQueue(file);
            else {
                filesQueue.put(file);
                // logger.info("文件：{}, 已放入队列中", file.getPath());
            }
        }
    }

    /**
     * 在文件下搜索关键字
     *
     * @param file  要搜索的文件
     * @param keyword   要搜索的关键字
     * @throws FileNotFoundException    抛出异常
     */
    private static void search(File file, String keyword) throws FileNotFoundException {
        try (Scanner in = new Scanner(file, "UTF-8")) {
            int lineNumber = 0;
            while (in.hasNextLine()) {
                lineNumber ++;
                String line = in.nextLine();
                if (line.contains(keyword)) {

                    logger.info("{}:{}:{}", file.getPath(), lineNumber, line);
                }
            }
        }
    }


    /**
     * 生产者线程：将目录下的文件放入到阻塞队列
     *
     * @param directory 要搜索的目录
     */
    public static void producer(File directory) {
        Runnable product = () -> {
            try {
                putIntoQueue(directory);
                filesQueue.put(DUMMY);
            } catch (InterruptedException e) {
                logger.error("文件放入队列异常：{}", e);

            }
        };
        new Thread(product).start();
    }

    /**
     * 消费者线程：从阻塞队列中拿取文件，并在该文件中搜索关键字
     *
     * @param keyword   要搜索的关键字
     */
    public static void customers(String keyword) {
        Runnable search = () -> {
            try {
                boolean done = true;
                while (done) {
                    File file = filesQueue.take();
                    if (file == DUMMY) {
                        // logger.info("队列中已没有文件");
                        filesQueue.put(file);
                        done = false;
                    } else search(file, keyword);
                }
            } catch (FileNotFoundException e) {
                logger.error("搜索关键字异常：{}", e);
            } catch (InterruptedException e) {
                logger.error("获取队列文件异常：{}", e);
            }
        };

        for (int i = 0; i < SEARCH_THREADS; i++) {
            new Thread(search).start();
        }
    }

    // 测试
    public static void main(String[] args) {
        boolean done = true;
        try (Scanner in = new Scanner(System.in)) {
            System.out.print("输入要搜索的目录（如：/Users/guohua.wei/WorkSpace/Idea-workspace/java-test/src/）：");
            String directory = in.nextLine();
            producer(new File(directory));

            System.out.print("输入要搜索的关键字（如：java）：");
            String keyword = in.nextLine();

            customers(keyword);
        }

    }
}