在java中使用线程进行并行处理

要么

您可以使用java并发的倒计时锁存来解决您的问题.

CountDownLatch如何工作？

CountDownLatch.java类定义了一个构造函数：

//构造一个用给定计数初始化的CountDownLatch.

public void CountDownLatch(int count) {...}

这个计数本质上就是锁存器应该等待的线程数.此值只能设置一次,而CountDownLatch不提供其他机制来重置此计数.

与CountDownLatch的第一次交互是主线程,它是等待其他线程的goind.这个主线程必须在启动其他线程后立即调用CountDownLatch.await()方法.执行将在await()方法上停止,直到其他线程完成执行.

其他N个线程必须引用latch对象,因为它们需要通知CountDownLatch对象它们已经完成了它们的任务.此通知通过以下方法完成：CountDownLatch.countDown();每次调用方法都会减少构造函数中设置的初始计数,因此,当所有N个线程都调用此方法时,count会达到零,并允许主线程通过await()方法恢复执行.

下面是一个简单的例子.在Decrementer之后调用了countDown()3次

CountDownLatch,the waiting Waiter is released from the await() call.
CountDownLatch latch = new CountDownLatch(3);

Waiter      waiter      = new Waiter(latch);
Decrementer decrementer = new Decrementer(latch);

new Thread(waiter)     .start();
new Thread(decrementer).start();

Thread.sleep(4000);

public class Waiter implements Runnable{

    CountDownLatch latch = null;

    public Waiter(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Waiter Released");
    }
}

public class Decrementer implements Runnable {

    CountDownLatch latch = null;

    public Decrementer(CountDownLatch latch) {
        this.latch = latch;
    }

    public void run() {

        try {
            Thread.sleep(1000);
            this.latch.countDown();

            Thread.sleep(1000);
            this.latch.countDown();

            Thread.sleep(1000);
            this.latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在您的情况下,您可以使用callable来创建线程而不是runnable,因为您需要从一个线程获取retrun值并且必须将该值传递给第二个线程.