如何保持线程执行，直到异步线程返回回调

Question

我有如下图所示的场景

这里的主线程是my java application.it打开一个WM线程来执行。 WM处理任务执行。他需要调用任务执行次数。 假设它包含任务T1，T2，T3

T3取决于T2，T2取决于T1。 WM首先调用RM来执行T1的任务执行。 T1可以在分页时给出响应，也可以在T1完成后给出响应。

问题是我如何等待T1完成然后开始T2的执行。如何在T1部分完成时发送数据在分页中发送时如何通知WM。

这是一个简单的场景，但是在T1，T2，T3，T4的情况下。 T3取决于T1和T2。

代码：

public class TestAsync implements TaskCallBack {
    public static ExecutorService exService = Executors.newFixedThreadPool(5);
    public static void main(String args[]) throws InterruptedException, ExecutionException{
        Task t1 = new Task();
        t1.doTask(new TestAsync());

    }

    public static ExecutorService getPool(){
        return exService;
    }

    @Override
    public void taskCompleted(String obj) {
        System.out.println(obj);
    }
}

class Task {
 public void doTask(TaskCallBack tcb) throws InterruptedException, ExecutionException{
     FutureTask<String> ft = new FutureTask<>(new Task1());
     TestAsync.getPool().execute(ft);
     tcb.taskCompleted(ft.get());
 }

}

class Task1 implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());               
        return "done";
    }

  interface TaskCallBack{
      public void TaskCompleted(String obj);
  }

}

Answer 1

这是一个非常有趣的话题。我面临着开发高度并行的网络数据包处理解决方案的类我将分享我的发现，但在此之前我应该​​说，对任何并行系统使用某种特殊解决方案总是一个坏主意。

如果没有适当的架构支持，调试，优化和进一步开发可能会成为一场噩梦。让我们说我们有三个相关的任务：

第一个解决方案

将引入composite or compound task抽象，以便让依赖任务以正确的顺序执行并摆脱延迟，等待/阻塞，复杂的任务管理等。

我将使用简化代码来说明这种方法：

/**
 * Defines a high-level task contract. 
 * Let's pretend it is enough to have it this simple.
 */
interface Task extends Runnable {

}

/**
 * Defines a simple way to group dependent tasks.
 * 
 * Please note, this is the simplest way to make sure dependent tasks will be
 * executed in a specified order without any additional overhead.
 */
class CompoundTasks implements Task {

    private List<Task> tasks = ...;

    public void add(Task task) {
        tasks.add(task);
    }

    @Override
    public void run() {
        for(Task t : tasks) {
           t.run();
        }
    }        
}

第二个解决方案

将让任务具有显式依赖关系，并使执行者意识到这一点。基本上，规则很简单 - 如果任务有未解决的依赖关系，它应该被推迟。这种方法很容易实现，效果很好。

请注意，由于需要一些资源来验证任务，管理队列等，第二种解决方案会引入微小的性能损失。

让我们发展基于任务的方法：

/**
 * Defines yet another abstraction to make dependencies 
 * visible and properly tracked. 
 * 
 */
abstract class DependentTask implements Task {

    private List<DependentTask> dependencies = ...;

    public void addDependency(DependentTask task) {
        dependencies.add(task);
    }

    /**
     * Verifies task can be processed. 
     */
    public boolean hasDependenciesResolved() {
        boolean result = true;
        for(DependentTask t : dependencies) {
            if(!t.hasDependenciesResolved()) {
                result = false;
                break;
            }
        }
        return result;
    }

    @Override
    public abstract void run();
}

/**
 * Implements a very basic queue aware of task dependencies.
 * 
 * Basically, the idea is just to avoid any blocking state. If task can't
 * be processed (because of unresolved dependencies) it should be 
 * postponed and verified later.
 */
class TaskQueue<T extends DependentTask> implements Runnable {        
    private Queue<T> queue = ...;

    @Override
    public void run() {
        while(true) {
            if(!queue.isEmpty()) {

                T task = queue.poll();

                // Verify all dependencies have been resolved.
                if(task.hasDependenciesResolved()) {
                    task.run();         // process task if there is no unresolved
                                        // dependencies
                }else{
                    queue.add(task);    // return task to the queue
                }

            }else{
                // sleep for some reasonable amount of time
            }
        }
    }        
}

这两种方法都很容易追踪，因此您始终能够了解正在发生的事情。

Answer 2

如果您知道T1和T2的任务数，则可以使用CountDownLatch。您最好的选择可能是在将T2任务添加到执行程序之前等待，直到所有T1任务完成（T2相同 - > T3）。

如果您无法更改添加代码，您还可以让每个T2任务等到所有T1任务完成，但如果任务添加无序，那么这将导致活动问题（执行程序线程池只填充睡眠线程）。