使用多线程读取多个 txt 文件搜索字符串

Question

我有一个包含 100 个 .txt 文件的文件夹，每个文件 20 或 + MB。 所有文件都有大约2*10^5 lines of UTF-8 encoded text。

什么是可能使用多线程来查找哪些文件包含固定密钥字符串的最快方法？ （包含的条件与 java .contains() 函数相同，即普通子字符串）。

我在 SO 上找到了几种方法，但没有使用 multithreading（为什么？），而且它们似乎都根据要求改变速度，我似乎无法理解哪个的方法对我来说更好。

例如这个超级复杂的方法：

https://codereview.stackexchange.com/questions/44021/fast-way-of-searching-for-a-string-in-a-text-file

似乎比使用BufferedReader 和.contains() 函数的简单逐行搜索慢2 倍。怎么可能？

如何才能充分发挥多线程的潜力？该程序在非常强大的多核机器上运行。

我要查找的输出是哪些文件包含该字符串，以及可能在哪一行。

Answer 1

下面的代码完成了这项工作。

它将进入您的目录并查找所有文件。 然后将为每个文件创建一个新线程并查找目标字符串。

确保根据需要更改TheThread类中文件夹和目标字符串的路径

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;


//class used for thread
class TheThread implements Runnable {

    int counter = 0;

    //to get stream of paths
    Stream<Path> streamOfFiles = Files.walk(Paths.get("./src/Multi_tasking/Files"));

    //List of total all files in the folder
    List<Path> listOfFiles = streamOfFiles.collect(Collectors.toList());

    //because Files.walk may throw IOException
    public TheThread() throws IOException {
    }


    @Override
    public void run() {

        //increments counter to access the indexes of the list
        counter++;

        //Calling the method for search file at index counter and  target String
        SearchTextInMultipleFilesUsingMultiThreading.lookIn(listOfFiles.get(counter), "target String");
    }
}

public class SearchTextInMultipleFilesUsingMultiThreading {

    //method responsible for searching the target String in file
    public static void lookIn(Path path, String text) {
        try {
            List<String> texts = Files.readAllLines(path);
            boolean flag = false;
            for (int i = 0; i < texts.size(); i++) {
                String str = texts.get(i);
                if (str.contains(text)) {
                    System.out.println("Found \"" + text + "\" in " + path.getFileName() + " at line : " + (i + 1) + " from thread : " + Thread.currentThread().getName());
                    flag = true;
                }
            }
            if (!flag) {
                System.out.println("\"" + text + "\" not found in " + path.getFileName() + " through thread : " + Thread.currentThread().getName());
            }

        } catch (IOException e) {
            System.out.println("Error while reading " + path.getFileName());
            e.printStackTrace();
        }
    }

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

        //creating object of our thread class
        TheThread theThread = new TheThread();

        //getting the number of files in the folder
        int numberOfFiles = theThread.listOfFiles.size() - 1;

        //if the folder doesn't contain any file at all
        if (numberOfFiles == 0) {
            System.out.println("No file found in the folder");
            System.exit(0);
        }

        //creating the List to store threads
        List<Thread> listOfThreads = new ArrayList<>();

        //keeping required number of threads inside the list
        for (int i = 0; i < numberOfFiles; i++) {
            listOfThreads.add(new Thread(theThread));
        }

        //starting all the threads
        for (Thread thread :
                listOfThreads) {
            thread.start();

        }
    }

}

Answer 2

我会让其他问题的答案不言自明，但多线程不太可能对数据存储在单个磁盘上的 I/O 绑定任务有所帮助。假设您的文件夹存储在单个磁盘上，磁盘缓存最优化的用例是单线程访问，因此这可能是最有效的解决方案。原因是从磁盘读取数据可能比在数据加载到内存后查看数据要慢，因此磁盘读取是速率限制的。

使用 BufferedReader 和 contains() 函数的简单解决方案可能是最快的，因为这是可能高度优化的库代码。

现在，如果您的数据被分片到多个磁盘上，则可能值得运行多个线程，具体取决于操作系统如何进行磁盘缓存。如果您要对不同的字符串进行多次搜索，在第一次搜索时并非全部都知道，因此单遍方法不起作用，那么将所有文件加载到内存中然后只进行多线程搜索可能是值得的在内存上。但是，您的问题不再是真正的文件搜索问题，而是更一般的数据搜索问题。