Java并发(Runnable+Thread)实现硬盘文件搜索功能

零、插播2020CSDN博客之星投票新闻

近日（1月11日-1月24日），2020CSDN博客之星评选正在火热进行中，作为码龄1年的小白有幸入选Top 200，首先很感谢CSDN官方把我选上，本来以为只是来凑热闹，看大佬们PK 。

综合过去9天大佬们战况，前10名大佬基本坐得很稳，后期出现黑马发力，势不可挡，都在冲刺Top 20，有了微妙的变化，不得不令人佩服点赞！真正的实力可以看出，文章数量不重要，更重要的是质量！一切用数据说话，如图：

截至 2021-01-20 11:50:02

看了大佬的惊人数据，与我差距甚大，不禁感慨，接下来看看我自己！

首先，很感谢每一位帮忙投票的粉丝和兄弟姐妹们，感谢您的关注和支持，经过大家上一周的共同努力，我已进入2020博客之星投票排行榜Top 100。

投票还有一周时间，进入更激烈更有悬念的阶段，希望读者们下来一周能投出您手中宝贵的票权，让我更进一步！

投票地址：https://bss.csdn.net/m/topic/blog_star2020/detail?username=charzous

或者扫码投票：

重点：每一个投票都会被记录，投了之后找Charzous帮忙也容易了（疯狂暗示投票拉票）！

比如，帮忙下载资源，或者博客一键三连，再次对每位帮我投票的粉丝表示感谢！ 😊新的一年，让我们一起变得更强！

即日起到24号，每天都可以投票哦，票数越多，贡献排行榜就越靠前，我就记住你的名字啦！

24号是否能和大佬们在顶峰相见，就靠大家了哈！

一、承上启下

前一篇学习了Java并发程序设计原理之后，为了对这个部分有了更深层的理解，并运用于实际场景中，所以我找了比较实际的案例进行实践——文件搜索，简单来说，这也是电脑文件系统中的一个常见功能，用户可以通过用户名搜索文件系统中符合条件的文件。

文件搜索的程序需要用到Java并发API中的Thread类和Runnable接口，其中一些重要的内容先简单了解一下。

二、Java中的多线程

线程类Thread，有两种方式创建执行线程。

1、扩展Thread类并重载run()方法

Thread类包含了丰富的方法，在实现线程时候必须重载run方法，扩展Thread类和调用start方法创建新的线程。其他常用方法：

getId()：获取Thread对象的标识符，线程整个生命周期中唯一不变的一个正整数。getName()/setName()：String类型，获取或设置Thread对象名。

getPriority()/setPriority()：获取或设置线程的优先级。值范围：Thread.MIN_PRIORITY~Thread.MAX_PRIORITY（1~10），创建时默认Thread.NORM_PRIORITY（5）。getState()：线程对象的状态。包括：NEW（新创建）、RUNNABLE（运行中）、BLOCKED（等待锁定）、WAITING（等待）、TIME_WAITING（有时间限制等待）、THREAD（完成）。

线程在一段时间中只能处于一种状态，而且是在JVM中的状态，不能映射到操作系统的线程状态。interrupt()：请求结束执行Thread对象。

interrupted()：检查中断状态，清除中断标志的值。

isInterrupted()：检查中断状态，不清除中断标志的值。

sleep()：线程执行睡眠时间，单位毫秒。

join()：暂停调用线程的执行，直到调用该方法的线程执行结束为止。

currentThread()：静态方法，返回实际执行当前任务的Thread对象。

2、实现Runnable接口

可以通过线程来执行Runnable对象，更灵活更改并发程序，还可以通过不同线程使用同一个Runnable对象。

相对来说，使用Runnable接口创建线程的方法更加推荐，它只定义了run方法，是每个线程的主方法。当执行start方法启动新线程时，就会调用run方法。

三、串行文件搜索

这里分为两种版本，串行（单线程）和并发（多线程），后续可以进行比较。

1、创建公共类Result保存搜索结果

/**
* Result.java
* @author Charzous
* @date 2021/1/20 11:00
*
*/

package SearchFiles;

public class Result {
boolean found;
String path;

public void setFound(boolean found){
this.found=found;
}

public boolean isFound(){
return this.found;
}

public void setPath(String path){
this.path=path;
}

public String getPath(){
return this.path;
}
}

2、查找算法

算法思路简单，通过初始路径，获取文件和目录内容，并与目标文件名进行比较，相同则记录Result，算法完成；不同则递归遍历文件，直到算法完成。

/**
*
* SerialSearch.java
* @author Charzous
* @date 2021/1/20 11:15
*
*/

package SearchFiles;

import java.io.File;

public class SerialFileSearch {
public static void searchFiles(File file,String fileName,Result result){
File[] contents;
contents=file.listFiles();

if ((contents==null)||(contents.length==0))
return;

for (File content:contents){
if (content.isDirectory())
searchFiles(content,fileName,result);
else{
if (content.getName().equals(fileName)){
 result.setPath(content.getAbsolutePath());
 result.setFound(true);
 System.out.println("Serial Search Path: "+result.getPath());
 return;
}
}
if (result.isFound())
return;
}
}

public static void main(String[] args) {
Result result=new Result();
File file=new File("D:\\");
long startTime=System.currentTimeMillis();
String fileName="maskOrder.txt";
SerialFileSearch.searchFiles(file,fileName,result);

if (!result.isFound())
System.out.println("未找到该文件："+fileName);
else
System.out.println("找到该文件："+fileName+"!");
System.out.println("查询时间："+(System.currentTimeMillis()-startTime)+"ms");
}
}

四、并行文件搜索(多线程)

1、创建ParallelGroupFileTask类

它实现所有用于查找文件的线程，实现Runnable接口，重载run方法，其中包括了处理目录的processDirectory方法，处理文件的processFile方法。

/**
* ParallelGroupFileTask.java
* @author Charzous
* @date 2021/1/20 11:31
*
*/
package SearchFiles;

import java.io.File;
import java.util.concurrent.ConcurrentLinkedQueue;

class ParallelGroupFileTask implements Runnable {
private final String fileName;
private final ConcurrentLinkedQueue<File> directories;
private final Result parallelResult;
private boolean found;

public ParallelGroupFileTask(String fileName, ConcurrentLinkedQueue<File> directories, Result parallelResult) {
this.fileName = fileName;
this.directories = directories;
this.parallelResult = parallelResult;
}

@Override
public void run() {
while (directories.size() > 0) {
File file = directories.poll();
try {
processDirectory(file,fileName,parallelResult);//递归
if (found) {
 System.out.println(Thread.currentThread().getName() + " has found the file");
 System.out.println("parallel search:Path :" + parallelResult.getPath());
 return;
}
} catch (Exception e) {
System.out.println(Thread.currentThread().getName() + " hae been interrupted");
}
}
}

public void processDirectory(File file, String fileName, Result parallelResult) throws InterruptedException {
File[] contents;
contents = file.listFiles();

if ((contents == null) || (contents.length == 0))
return;

for (File content : contents) {
if (content.isDirectory()) {
processDirectory(content, fileName, parallelResult);
if (Thread.currentThread().isInterrupted())
 throw new InterruptedException();

if (found)
 return;
} else {
processFile(content, fileName, parallelResult);//递归
if (Thread.currentThread().isInterrupted())
 throw new InterruptedException();
if (found)
 return;
}
}
}

public void processFile(File content, String fileName, Result parallelResult) {
if (content.getName().equals(fileName)) {
parallelResult.setPath(content.getAbsolutePath());
this.found = true;
}
}

public boolean getFound() {
return found;
}

}

2、多线程算法

创建ParallelGroupFileSearch类，其中包括了存放基本路径的线程安全的列表ConcurrentLinkedQueue，然后创建新线程，数量有JVM中可用的线程数量，通过Runtime的availableProcessors方法获得。

其中，若某个线程找到目标文件，会使用interrupt方法取消其他线程的执行。具体实现代码如下：

/**
* ParallelGroupFileSearch.java
* @author Charzous
* @date 2021/1/20 11:40
*
*/
package SearchFiles;

import java.io.File;
import java.util.concurrent.ConcurrentLinkedQueue;

public class ParallelGroupFileSearch {
public static void searchFiles(File file, String fileName, Result parallelResult) {
ConcurrentLinkedQueue<File> directories = new ConcurrentLinkedQueue<>();
File[] contents = file.listFiles();

for (File content : contents) {
if (content.isDirectory())
directories.add(content);
}
int numThreads = Runtime.getRuntime().availableProcessors();
Thread[] threads = new Thread[numThreads];

ParallelGroupFileTask[] tasks = new ParallelGroupFileTask[numThreads];
for (int i = 0; i < numThreads; i++) {
tasks[i] = new ParallelGroupFileTask(fileName, directories, parallelResult);
threads[i] = new Thread(tasks[i]);
threads[i].start();
}

boolean finish = false;

int numFinished = 0;
while (!finish) {
numFinished = 0;
for (int i = 0; i < threads.length; i++) {
if (threads[i].getState() == Thread.State.TERMINATED) {
 numFinished++;
 if (tasks[i].getFound())
 finish = true;
}
}
if (numFinished == threads.length)
finish = true;
}
if (numFinished != threads.length) {
for (Thread thread : threads)
thread.interrupt();
}

}

public static void main(String[] args) {
Result result=new Result();
File file=new File("D:\\");
String fileName="maskOrder.txt";
long startTime=System.currentTimeMillis();

ParallelGroupFileSearch.searchFiles(file,fileName,result);

System.out.println("查询时间："+(System.currentTimeMillis()-startTime)+"ms");
}

}

五、结果

1、串行（单线程）

串行版本多次测试结果用时在1900ms左右！

10次测试数据：

查询时间：1978ms 2036 1860 1926 1861 2100 1889 2030 1905 1990

2、并发（多线程）

并发版本多线程测试用时在1400ms左右！

10次测试数据：

查询时间：1441ms 1368 1258 1546 1444 1430 1490 1432 1338 1435

从简单的测试结果可以看出，并发搜索的算法速度提升明显。

这一篇通过实际的案例进行实践——文件搜索，简单来说，这也是电脑文件系统中的一个常见功能，用户可以通过用户名搜索文件系统中符合条件的文件。Runnable接口和Thread类的基本使用也有了更深的认识。在文件搜索这个案例中，学习了Java并发原理的实际应用，首先设计一种串行的版本，然后再实现并发的版本，这也是一个改进的过程。

来源：https://blog.csdn.net/Charzous/article/details/112853937