为什么我的线程不能同时启动？爪哇

Question

我有可变数量的线程用于并行下载。我用过这个，

for(int i = 0; i< sth; i++){
       thrList.add(new myThread (parameters));
       thrList.get(i).start();
       thrList.get(i).join();

}

我不知道为什么，但他们在等待对方完成。使用线程时，我应该得到混合打印输出，因为那时有几个线程运行该代码。但是，当我将它们打印出来时，它们总是有序的，一个线程等待前一个线程首先完成。我只希望他们加入主线程，而不是互相等待。我注意到当我在并行下载时测量时间。

我该如何解决这个问题？他们为什么要按顺序做？

在我的 .java 中， 有带有运行的 MyThread 类，有带有静态方法和变量的 Downloader 类。他们会是造成这种情况的原因吗？静态方法和变量？

我该如何解决这个问题？

Answer 1

您正在创建一个线程，等待它完成（加入），创建一个新线程，等待它完成（加入）等等。

您应该阅读有关线程的 java 文档以了解大多数方法的作用： http://download.oracle.com/javase/tutorial/essential/concurrency/index.html 和 http://download.oracle.com/javase/6/docs/api/java/lang/Thread.html

Answer 2

简单。问题出在这里：

for(int i = 0; i< sth; i++){
       thrList.add(new myThread (parameters));
       thrList.get(i).start(); // problem
       thrList.get(i).join();  // problem
}

具体来说，循环的每次迭代都会创建一个线程，启动它然后等待它再次加入。这就是它们串行运行的原因。

你需要做的是：

for(int i = 0; i< sth; i++){
       thrList.add(new myThread (parameters));
       thrList.get(i).start();
}

for(int i = 0; i< sth; i++){
       thrList.get(i).join();
}

这将经历启动所有线程的过程，然后它将循环遍历每个线程并等待它退出。

Answer 3

使用 ExecutorService 会更好

ExecutorService es = Executors.newCachedThreadPool();
// pool is reusable

List<Callable<Void>> callables = new ArrayList<Callable<Void>>();
for(int i=0;i<sth;i++) callables.add(new MyCallable(i));
for(Future<Void> futures : es.invokeAll(callables))
    futures.get();

Answer 4

您启动一个线程并立即加入其中，从而使整个线程无用，因为您正在等待线程完成。

   thrList.get(i).start();
   thrList.get(i).join();

您应该使用同步队列，生成的线程自己从中获取参数，等待队列为空，然后继续。

Answer 5

join 方法等待所选线程死亡。当前线程（执行触发事件的循环的线程）正在等待您刚刚开始死亡的线程，然后再开始执行下一个线程。

Answer 6

只需执行 2 个循环，首先将它们全部启动，然后将它们全部加入。

Answer 7

对于我从您的问题中得到的解释，由于没有明确说明，您有多个下载器线程并希望同步它们。在这种情况下，您需要使用外部结构，例如 CountdownLatch。 CountdownLatch 是一种“同步辅助工具，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。”把它想象成一个计数器，每次下载线程完成时都会减少，当倒计时达到 0 时，所有线程都应该完成它们的工作。

让我们看一些直接取自 CountdownLatch 官方 javadoc 的代码：

 CountDownLatch startSignal = new CountDownLatch(1);
 CountDownLatch doneSignal = new CountDownLatch(N);

 for (int i = 0; i < N; ++i) // create and start threads
     new Thread(new Worker(startSignal, doneSignal)).start(); 

 startSignal.countDown(); // Threads are waiting for startSignal's counter to reach 0 and start their work, more or less at the same time
 doneSignal.await(); // The current thread will sleep at this point until all worker threads have each one called doneSignal.countDown() and the countdown reaches 0

 joinDownloadedPieces(); // At this point is safe to assume that your threads have finished and you can go on with anything else    

你的 worker Runnable/Thread 类看起来像这样：

public void run() {
    startSignal.await(); // Wait until given the go

    downloadSomething();

    doneSignal.countDown(); // Notify that we are done here
}

我说可以安全地假设，因为在所有线程完成之前，您将不得不处理可能在等待期间唤醒您的线程的 InterruptedExceptions。有关更多信息，我建议您查看java.util.concurrent 包。恕我直言，它是 Java 的最佳瑰宝之一，文档详尽，通常足以理解每个结构的功能。