Java线程wait（）和notify（）与并行任务

Question

I have a requirement where in a single method call I want to hit three different collections to retrieve data. Right now I am doing one after another to get data. Instead, I want to create three threads where each should execute in parallel. Then after every thing is completed, I want to merge the results and send it to the client.

public List<String> getUserData() {
    // all the tasks should execute in parallel & finally
    // merge all the result & send to the client.
    task1(); 
    task2();
    task3();
}

Can any one help me to solve the problem?

Answer 1

Pass same CyclicBarrier to all threads.

// you have 3 threads,
CyclicBarrier meetingPoint=new CyclicBarrier(3);

// assigns their "barrier" variable to cyclic barrier
YourThreadGenerator thread1=new YourThreadGenerator(meetingPoint);
YourThreadGenerator thread2=new YourThreadGenerator(meetingPoint);
YourThreadGenerator thread3=new YourThreadGenerator(meetingPoint);

and then in each of three threads,

this.barrier.await();

this ensures all threads wait until all other threads(which have same cyclic barrier instruction) hits this line, then program flow continues for them and they can repeat this process.

You dont even need explicit synchronization. But this is slow for many threads. If you have several threads, its ok.

To make it easier, you can count main thread as 4th thread and call

meetingPoint.await();

in it. But it needs to be instantiated with 1 extra thread as

 CyclicBarrier meetingPoint=new CyclicBarrier(4);

Answer 2

An ExecutorService provides robust, high-level support for general purpose parallel processing. Here, I'm assuming your tasks are different methods ( task1() , task2() , …) provided by some service ( svc ) that return records, and the result is the union of these results.

void getUserData1()
  throws InterruptedException, ExecutionException, CancellationException
{
  List<Callable<List<String>>> tasks = Arrays.asList(svc::task1, svc::task2, svc::task3);
  ExecutorService workers = Executors.newFixedThreadPool(tasks.size());
  List<Future<List<String>>> tickets;
  try {
    tickets = workers.invokeAll(tasks, 10, TimeUnit.SECONDS);
  }
  finally {
    workers.shutdown();
  }
  List<String> results = new ArrayList<>();
  for (Future<List<String>> ticket : tickets)
    results.addAll(ticket.get());
}

Exceptions would need to be handled; here, I'm specifying a 10-second timeout. If some results are not ready in that time, a CancellationException is thrown. If another thread cancels this request by interrupting this thread, InterruptedException is thrown, and if a task fails, ExecutionException is thrown. In all of these cases, it's likely that you'd respond to the client in the same way, with an "internal error" message.

In this example, the ExecutorService is created and destroyed with every request, which is costly. In an application with a well-defined lifecycle defining when the service could be created and destroyed, it could be reused for all requests. In that case, you may want a cached thread pool instead of a fixed thread pool.

The newer ForkJoinPool , or the parallel Stream functionality built on fork-join could also be used, but it's suitable for a narrower set of tasks. If the tasks don't block or throw checked exceptions, Stream is concise. If the tasks are time-consuming but can easily be recursively sub-divided into smaller tasks, ForkJoinPool might be worth using. Here's an example using a Stream :

List<String> getUserData2()
{
  Stream<Supplier<List<String>>> s = Stream.of(svc::task1, svc::task2, svc::task3);
  return s.parallel().map(Supplier::get).flatMap(List::stream).collect(Collectors.toList());
}