推荐一种在Java中将同步方法转为异步的更好方法

Question

类中有一些同步运行的方法。我希望它们异步运行，第一个想法是包装它，并使用 switch 枚举来决定应该调用哪个函数。但对于调用的每个方法，我都需要包装类中的一个新方法和一个新的枚举。看起来像这样：

public class QueuedShow implements InterfaceShowAlert, Runnable {
    private Class Action {
       String param1;
       public static enum ActionEnum{
          NEW, CHECK, UPDATE, DELETE, DISPLAY;
       }
       public ActionEnum todo;
       public Action(ActionEnum todo, Object param){
          this.todo=todo;
          this.param1=param;
       }
    }
    private BlockingQueue<Action> actionList;
    public void run(){
       while(true){
           Action action=actionList.take(); //THIS waits until queue isn't empty
           switch(action.todo){
           case NEW: //Call original function
              ....
           }
       }
    }
    public void new(String param){
       actionList.add(new Action(NEW, param));
    }
}

然后我了解了反思，我有了一个新想法。即使用字符串来调用方法，而不是直接调用方法。 包装类读取并解析字符串，并使用反射获取类和包含方法。它将参数和方法对象放入一个类中，该类被放入队列中。现在该类使用 Method.invoke(params) 而不是使用枚举进行切换。但这样做的问题是编译时类型检查丢失了。

当然，所有这些仅适用于 void 的方法，但当然我们也可以使用 Future 类返回值。

现在是否有任何框架已经实现了将同步调用转变为异步调用，或者您是否知道执行此操作的任何其他方法。

Answer 1

这是推荐的方法：使用

abstract public class Action<T> implements Runnable {
  private final T param;

  public Action(T param) {
    this.param = param;
  }

  @Override
  public final void run() {
    work(param);
  }

  abstract protected void work(T param);
}

：

ExecutorService exec = Executors.newSingleThreadExecutor();
while (/* more actions need to be done */) {
  exec.submit(action);
}
exec.shutdown();
exec.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

Answer 2

处理此问题的正常方法是使用 java 5 执行器框架，如此处所示。这将允许您对同步和异步实现使用相同的模式，并且您只需选择要使用的 ExecutorService 即可。

Answer 3

但这与
krosenvoid，这意味着包装器
每个方法都需要类，
现在实现一个work(param)方法。

要么选择完全动态和反射的东西，在其中传递 String 作为方法名称，并传递 Object 作为参数。因为 Java 是静态类型的（与 Groovy 这样的动态语言不同），这将是可怕的并且可能充满强制转换，但您可以做到。

您当前的解决方案列出了带有枚举的异步方法。因此，如果不更改代码，它就不是完全动态的和可扩展的。也就是说，您需要为每个新方法添加一个新的enum。

public static enum ActionEnum{
          NEW, CHECK, UPDATE, DELETE, DISPLAY;
}

如果对您来说没问题，那么使用 Action 或 Callable 也应该可以，如其他答案中的建议。对于每个新方法，您需要编写一个新的 Action 或 Callable 以便静态定义方法调用。

 protected void work(String param)
 {
      myObject.theMethodToDispatch( param );
 }

我同意这是更多的样板代码，但仍然相当小。最大的胜利是，你的代码不是反射（并且不应该进行强制转换），并且你可以享受静态类型语言的好处：你可以重构方法名称，如果类型参数不匹配，编译器会警告你， ETC。