在java中使用main和junit获得不同的结果

当我测试一个简单的生产者/消费者示例时，得到了一个非常奇怪的结果，如下所示

如果我使用main（）测试以下代码，我将得到正确的预期结果

但是我只能正确地获取第一个目录，其余的工作都被JUnit删除了

确切的原因是什么

工作代码：

import java.io.File;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.junit.Test;

public class TestProducerAndConsumer {

    public static void main(String[] args) {
        BlockingQueue<File> queue = new LinkedBlockingQueue<File>(1000);

        new Thread(new FileCrawler(queue, new File("C:\\"))).start();
        new Thread(new Indexer(queue)).start();
    }
}

导入java.io.File；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.LinkedBlockingQueue；
导入org.junit.Test；
公共类TestProducerAndConsumer{
公共静态void main（字符串[]args）{
BlockingQueue=新的LinkedBlockingQueue（1000）；
新线程（新文件爬虫程序（队列，新文件（“C:\\”）））.start（）；
新线程（新索引器（队列））.start（）；
}
}

错误代码：

import java.io.File;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.junit.Test;

public class TestProducerAndConsumer {

    @Test
    public void start2() {
        BlockingQueue<File> queue = new LinkedBlockingQueue<File>(1000);

        new Thread(new FileCrawler(queue, new File("C:\\"))).start();
        new Thread(new Indexer(queue)).start();
    }
}

import java.io.File;
import java.util.Arrays;
import java.util.concurrent.BlockingQueue;

public class FileCrawler implements Runnable {
    private final BlockingQueue<File> fileQueue;
    private final File root;
    private int i = 0;

    public FileCrawler(BlockingQueue<File> fileQueue, File root) {
        this.fileQueue = fileQueue;
        this.root = root;
    }

    @Override
    public void run() {
        try {
            craw(root);
        } catch (InterruptedException e) {
            System.out.println("shit!");
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }

    }

    private void craw(File file) throws InterruptedException {
        File[] entries = file.listFiles();
        //System.out.println(Arrays.toString(entries));
        if (entries != null && entries.length > 0) {
            for (File entry : entries) {
                if (entry.isDirectory()) {
                    craw(entry);
                } else {
                    fileQueue.offer(entry);
                    i++;
                    System.out.println(entry);
                    System.out.println(i);
                }
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        FileCrawler fc = new FileCrawler(null, null);
        fc.craw(new File("C:\\"));
        System.out.println(fc.i);
    }

}




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

public class Indexer implements Runnable {

    private BlockingQueue<File> queue;

    public Indexer(BlockingQueue<File> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                indexFile(queue.take());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void indexFile(File file) {
        System.out.println("Indexing ... " + file);

    }
}

导入java.io.File；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.LinkedBlockingQueue；
导入org.junit.Test；
公共类TestProducerAndConsumer{
@试验
公开作废开始2（）{
BlockingQueue=新的LinkedBlockingQueue（1000）；
新线程（新文件爬虫程序（队列，新文件（“C:\\”）））.start（）；
新线程（新索引器（队列））.start（）；
}
}

其他功能代码：

import java.io.File;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.junit.Test;

public class TestProducerAndConsumer {

    @Test
    public void start2() {
        BlockingQueue<File> queue = new LinkedBlockingQueue<File>(1000);

        new Thread(new FileCrawler(queue, new File("C:\\"))).start();
        new Thread(new Indexer(queue)).start();
    }
}

import java.io.File;
import java.util.Arrays;
import java.util.concurrent.BlockingQueue;

public class FileCrawler implements Runnable {
    private final BlockingQueue<File> fileQueue;
    private final File root;
    private int i = 0;

    public FileCrawler(BlockingQueue<File> fileQueue, File root) {
        this.fileQueue = fileQueue;
        this.root = root;
    }

    @Override
    public void run() {
        try {
            craw(root);
        } catch (InterruptedException e) {
            System.out.println("shit!");
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }

    }

    private void craw(File file) throws InterruptedException {
        File[] entries = file.listFiles();
        //System.out.println(Arrays.toString(entries));
        if (entries != null && entries.length > 0) {
            for (File entry : entries) {
                if (entry.isDirectory()) {
                    craw(entry);
                } else {
                    fileQueue.offer(entry);
                    i++;
                    System.out.println(entry);
                    System.out.println(i);
                }
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        FileCrawler fc = new FileCrawler(null, null);
        fc.craw(new File("C:\\"));
        System.out.println(fc.i);
    }

}




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

public class Indexer implements Runnable {

    private BlockingQueue<File> queue;

    public Indexer(BlockingQueue<File> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                indexFile(queue.take());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void indexFile(File file) {
        System.out.println("Indexing ... " + file);

    }
}

导入java.io.File；
导入java.util.array；
导入java.util.concurrent.BlockingQueue；
公共类FileCrawler实现可运行{
私有最终阻塞队列文件队列；
私有最终文件根；
私有整数i=0；
公共文件爬虫程序（阻止队列文件队列，文件根）{
this.fileQueue=fileQueue；
this.root=根；
}
@凌驾
公开募捐{
试一试{
craw（根）；
}捕捉（中断异常e）{
System.out.println（“妈的！”）；
e、 printStackTrace（）；
Thread.currentThread（）.interrupt（）；
}
}
私有void craw（文件）抛出中断异常{
File[]entries=File.listFiles（）；
//System.out.println（Arrays.toString（entries））；
if（entries！=null&&entries.length>0）{
用于（文件条目：条目）{
if（entry.isDirectory（））{
craw（入境）；
}否则{
fileQueue.offer（条目）；
i++；
系统输出打印项次（输入）；
系统输出打印LN（i）；
}
}
}
}
公共静态void main（字符串[]args）引发InterruptedException{
FileCrawler fc=新的FileCrawler（null，null）；
fc.craw（新文件（“C:\\”）；
系统输出打印项次（fc.i）；
}
}
导入java.io.File；
导入java.util.concurrent.BlockingQueue；
公共类索引器实现可运行{
私有阻塞队列；
公共索引器（阻止队列）{
this.queue=队列；
}
@凌驾
公开募捐{
试一试{
while（true）{
indexFile（queue.take（））；
}
}捕捉（中断异常e）{
Thread.currentThread（）.interrupt（）；
}
}
私有void索引文件（文件）{
System.out.println（“索引…”+文件）；
}
}

Junit可能允许JVM和线程在测试完成后终止，因此线程无法完成工作

尝试等待线程“加入”：

Thread crawlerThread = new Thread(new FileCrawler(queue, new File("C:\\")));
Thread indexerThread = new Thread(new Indexer(queue));
crawlerThread.start();
indexerThread.start();
// 
// wait for them to finish.
crawlerThread.join();
indexerThread.join();

这应该会有所帮助

---

。。另一个可能出错的地方是日志输出（通过Log4J）有时会在执行结束时被截断；冲洗和暂停会有所帮助。但我不认为这会影响你在这里。

成功了，谢谢！您的代码中需要一个小小的更改。new Thread（）.start（）返回void而不是Thread。谢谢@user2351730，修复：）很高兴我能帮上忙。