Java线程等待值_Java_Multithreading_Wait

Java线程等待值

java multithreading

Java线程等待值,java,multithreading,wait,Java,Multithreading,Wait,我有以下情况：为了运行一个算法，我必须运行几个线程，每个线程都会在它死之前设置一个实例变量x。问题是这些线程不会立即返回： public Foo myAlgorithm() { //create n Runnables (n is big) //start these runnables (may take long time do die) //i need the x value of each runnable here, but they havent fin

我有以下情况：

为了运行一个算法，我必须运行几个线程，每个线程都会在它死之前设置一个实例变量x。问题是这些线程不会立即返回：

public Foo myAlgorithm()
{
    //create n Runnables (n is big)
    //start these runnables (may take long time do die)

    //i need the x value of each runnable here, but they havent finished yet!

    //get average x from all the runnables

    return new Foo(averageX);
}

我应该使用等待通知吗？还是我应该嵌入一个while循环并检查终止

谢谢大家

你可以向

java.util.concurrent.Future

和所有相关的东西，如线程池、执行器等了解你自己。

Future

是一个带有返回值的线程。

你可以向

java.util.concurrent.Future

和所有相关的东西，如线程池，执行者等：一个

未来

是一个具有返回值的线程。

创建一些共享存储来保存每个线程的

值，或者如果足够的话只存储总和。使用等待线程终止。完成后，每个线程都会调用，

myAlgorithm

方法将使用该方法等待它们

编辑：以下是我建议的方法的完整示例。它创建了39个工作线程，每个线程向共享和中添加一个随机数。当所有工人完成后，计算并打印平均值

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

class Worker implements Runnable {

    private final AtomicInteger sum;
    private final CountDownLatch latch;

    public Worker(AtomicInteger sum, CountDownLatch latch) {
        this.sum = sum;
        this.latch = latch;
    }

    @Override
    public void run() {
        Random random = new Random();

        try {
            // Sleep a random length of time from 5-10s
            Thread.sleep(random.nextInt(5000) + 5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Compute x
        int x = random.nextInt(500);

        // Add to the shared sum
        System.out.println("Adding " + x + " to sum");
        sum.addAndGet(x);

        // This runnable is finished, so count down
        latch.countDown();
    }
}

class Program {

    public static void main(String[] args) {
        // There will be 39 workers
        final int N = 39;

        // Holds the sum of all results from all workers
        AtomicInteger sum = new AtomicInteger();
        // Tracks how many workers are still working
        CountDownLatch latch = new CountDownLatch(N);

        System.out.println("Starting " + N + " workers");

        for (int i = 0; i < N; i++) {
            // Each worker uses the shared atomic sum and countdown latch.
            Worker worker = new Worker(sum, latch);

            // Start the worker
            new Thread(worker).start();
        }

        try {
            // Important: waits for all workers to finish.
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Compute the average
        double average = (double) sum.get() / (double) N;

        System.out.println("    Sum: " + sum.get());
        System.out.println("Workers: " + N);
        System.out.println("Average: " + average);
    }

}

编辑：只是为了好玩，下面是一个使用和的示例