Question

所以有点背景;

我正在开发一个项目，其中servlet将在文件系统中的许多文本文件上发布爬虫。我在考虑将负载分成多个线程，例如：

抓取工具进入目录，找到3个文件和6个目录。它将开始处理文件并使用新的爬虫程序为其他目录启动一个线程。因此，从我的创建者类中，我将在基本目录上创建一个爬虫。爬虫将评估工作负载，如果认为需要，它将在另一个线程下生成另一个爬虫。

我的抓取工具类看起来像这样

package com.fujitsu.spider;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;

public class DocumentSpider implements Runnable, Serializable {

private static final long serialVersionUID = 8401649393078703808L;
private Spidermode currentMode = null;
private String URL = null;
private String[] terms = null;
private float score = 0;

private ArrayList<SpiderDataPair> resultList = null;

public enum Spidermode {
    FILE, DIRECTORY
}

public DocumentSpider(String resourceURL, Spidermode mode, ArrayList<SpiderDataPair> resultList) {
    currentMode = mode;
    setURL(resourceURL);
    this.setResultList(resultList);
}

@Override
public void run() {
    try {
        if (currentMode == Spidermode.FILE) {
            doCrawlFile();
        } else {
            doCrawlDirectory();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    System.out.println("SPIDER @ " + URL + " HAS FINISHED.");
}

public Spidermode getCurrentMode() {
    return currentMode;
}

public void setCurrentMode(Spidermode currentMode) {
    this.currentMode = currentMode;
}

public String getURL() {
    return URL;
}

public void setURL(String uRL) {
    URL = uRL;
}

public void doCrawlFile() throws Exception {
    File target = new File(URL);

    if (target.isDirectory()) {
        throw new Exception(
                "This URL points to a directory while the spider is in FILE mode. Please change this spider to FILE mode.");
    }

    procesFile(target);
}

public void doCrawlDirectory() throws Exception {
    File baseDir = new File(URL);

    if (!baseDir.isDirectory()) {
        throw new Exception(
                "This URL points to a FILE while the spider is in DIRECTORY mode. Please change this spider to DIRECTORY mode.");
    }

    File[] directoryContent = baseDir.listFiles();

    for (File f : directoryContent) {
        if (f.isDirectory()) {
            DocumentSpider spider = new DocumentSpider(f.getPath(), Spidermode.DIRECTORY, this.resultList);
            spider.terms = this.terms;
            (new Thread(spider)).start();
        } else {
            DocumentSpider spider = new DocumentSpider(f.getPath(),      Spidermode.FILE, this.resultList);
            spider.terms = this.terms;
            (new Thread(spider)).start();
        }
    }
}

public void procesDirectory(String target) throws IOException {
    File base = new File(target);
    File[] directoryContent = base.listFiles();

    for (File f : directoryContent) {
        if (f.isDirectory()) {
            procesDirectory(f.getPath());
        } else {
            procesFile(f);
        }
    }
}

public void procesFile(File target) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(target));
    String line;
    while ((line = br.readLine()) != null) {

        String[] words = line.split(" ");
        for (String currentWord : words) {
            for (String a : terms) {
                if (a.toLowerCase().equalsIgnoreCase(currentWord)) {
                    score += 1f;
                }
                ;
                if (currentWord.toLowerCase().contains(a)) {
                    score += 1f;
                }
                ;
            }
        }
    }

    br.close();
    resultList.add(new SpiderDataPair(this, URL));
}

public String[] getTerms() {
    return terms;
}

public void setTerms(String[] terms) {
    this.terms = terms;
}

public float getScore() {
    return score;
}

public void setScore(float score) {
    this.score = score;
}

public ArrayList<SpiderDataPair> getResultList() {
    return resultList;
}

public void setResultList(ArrayList<SpiderDataPair> resultList) {
    this.resultList = resultList;
}

}

我面临的问题是，在我的根爬虫中，我有来自每个我想要进一步处理的爬虫的结果列表。处理来自此列表的数据的操作是从servlet（或此示例的main方法）调用的。但是，在所有爬网程序完成处理之前，始终会调用操作。因此启动操作以过早处理结果，这导致数据不完整。

我尝试使用连接方法解决这个问题，但遗憾的是我似乎无法解决这个问题。

package com.fujitsu.spider;

import java.util.ArrayList;

import com.fujitsu.spider.DocumentSpider.Spidermode;

public class Main {

public static void main(String[] args) throws InterruptedException {
    ArrayList<SpiderDataPair> results = new ArrayList<SpiderDataPair>();
    String [] terms = {"SERVER","CHANGE","MO"};

    DocumentSpider spider1 = new DocumentSpider("C:\\Users\\Mark\\workspace\\Spider\\Files", Spidermode.DIRECTORY, results);
    spider1.setTerms(terms);

    DocumentSpider spider2 = new DocumentSpider("C:\\Users\\Mark\\workspace\\Spider\\File2", Spidermode.DIRECTORY, results);
    spider2.setTerms(terms);

    Thread t1 = new Thread(spider1);
    Thread t2 = new Thread(spider2);


    t1.start();
    t1.join();

    t2.start();
    t2.join();

    for(SpiderDataPair d : spider1.getResultList()){
        System.out.println("PATH -> " + d.getFile() + " SCORE -> " + d.getSpider().getScore());
    }

    for(SpiderDataPair d : spider2.getResultList()){
        System.out.println("PATH -> " + d.getFile() + " SCORE -> " + d.getSpider().getScore());
    }

}

}

TL：DR

我真的希望理解这个主题，所以任何帮助都会非常感激！

Answer 1

您的代码需要进行一些更改：

在蜘蛛中：

List<Thread> threads = new LinkedList<Thread>();
for (File f : directoryContent) {
    if (f.isDirectory()) {
        DocumentSpider spider = new DocumentSpider(f.getPath(), Spidermode.DIRECTORY, this.resultList);
        spider.terms = this.terms;
        Thread thread = new Thread(spider);
        threads.add(thread)
        thread.start();
    } else {
        DocumentSpider spider = new DocumentSpider(f.getPath(),      Spidermode.FILE, this.resultList);
        spider.terms = this.terms;
        Thread thread = new Thread(spider);
        threads.add(thread)
        thread.start();
    }
}
for (Thread thread: threads) thread.join()

我们的想法是为每个蜘蛛创建一个新线程并启动它。一旦它们全部运行，你就等到蜘蛛本身完成之前完成每个开启。这样每个蜘蛛线程都会一直运行，直到完成所有工作（因此顶部线程运行直到所有子项及其子项都完成）。

你还需要改变你的跑步者，使它能够并行地运行两个蜘蛛，而不是像这样一个接一个地运行：

Thread t1 = new Thread(spider1);
Thread t2 = new Thread(spider2);
t1.start();
t2.start();
t1.join();
t2.join();

Answer 2

对于此任务，您应该使用比Thread更高级别的库。我建议一般特别关注ExecutorService和java.util.concurrent。那里有抽象可以管理所有线程问题，同时为格式良好的任务提供一个适当保护的环境来运行。

针对您的具体问题，我建议使用某种阻塞任务队列和标准的生产者 - 消费者体系结构。每个任务都知道如何确定其路径是文件还是目录。如果是文件，则处理该文件;如果它是目录，则抓取目录的直接内容并为每个子路径排队新任务。您还可以使用一些正确同步的共享状态来限制处理的文件数量，深度等。此外，该服务还提供等待终止其任务的能力，使“加入”更简单。

使用此体系结构，您可以将线程和线程管理（由ExecutorService处理）的概念与任务的业务逻辑（通常为Runnable或Callable）分离。服务本身具有调整实例化方式的能力，例如固定的最大线程数或可伸缩数，具体取决于存在多少并发任务（请参阅java.util.concurrent.Executors上的工厂方法）。 Thread比它们执行的Runnable更昂贵，会被重新用来节省资源。

如果您的目标主要是在生产质量方面起作用的功能，那么图书馆就是您的选择。但是，如果您的目标是了解线程管理的底层细节，那么您可能需要调查使用锁存器和线程组来管理它们的较低级别，公开实现的详细信息以便您可以使用细节。

Java线程 - 等待所有子线程继续

2 个答案: