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

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
            }
        }
    }        
}

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