java - 创建需要跨线程共享全局数据的 XML-RPC 服务时如何避免并发异常

Question

我正在 Java 中使用 Redstone XML-RPC library 创建 XML-RPC 服务器。服务器负责在系统上启动命令，然后发回响应。例如，用户告诉服务器执行ls，服务器返回文件列表。同样，用户可以执行异步命令并获取进程 ID 以供稍后查询。所有这些方法都位于 Command 的一个大子类下，该子类是主类 RPCServlet extends XmlRpcServlet 的一部分。

为了实现这一目标，我保留了实例的全局HashMap。当异步命令进入时，我创建一个扩展线程的 ProcessManager 类的实例。然后，我将其添加到 instances 哈希中，运行它，并将 ID 返回给用户。当对该 ID 进行查询时，我会在全局哈希中查找它，并返回其完整或部分状态(取决于它是否已完成)。

当它只是一个接一个的请求时，这可以正常工作，但是当您真正开始使用大量对全局哈希实例进行操作的请求时，它会出现并发异常。

现在这是我的困惑点:

• 当请求传入时，是否会创建一个 Command 类的新对象，还是永远坐在那里接收命令的一个对象？接下来，每个请求如何查看实例的全局哈希？这是我的初始化代码

  公共(public)类 RPCServlet 扩展 XmlRpcServlet {

  @Override
  public void init(ServletConfig servletConfig) throws ServletException {
      super.init(servletConfig);  
      getXmlRpcServer().addInvocationHandler("Command", new Command(instances));  
  }
  

  }

• 当我尝试解决并发异常问题时，我使用 syncronized 或 ConcurrentHashMap 而不是 HashMap。不管怎样，我就这样陷入了僵局。为什么会这样？

• 我的实例的全局 HashMap 应该去哪里？在 RPCServlet 中？它的子类Command？

以下是我遇到这些并发异常的方法:

1. 我创建了一堆异步命令，然后尝试将它们全部杀死
2. 我启动了许多不同的客户端来执行此操作，并且不可避免地会遇到并发异常。

这是asyncCmd的样子:

public HashMap asyncCmd(XmlRpcStruct struct) throws XmlRpcFault {
            HashMap hash;
            if (struct.containsKey("command")) {
                ProcessManager proc = new ProcessManager(struct);
                boolean validInput = proc.readInHashValues();
                if (!validInput) {
                    throw new XmlRpcFault(400, proc.procResult.getTopError());
                }
                int id = proc.objectId;

                instances.put(id, proc);

                proc.start();
                String a;
                if ((a = proc.procResult.getTopError()) != null) {
                    throw new XmlRpcFault(500, a);
                }

                hash = new HashMap();
                hash.put("id", id);
                return hash;
            } else {
                throw new XmlRpcFault(400, "Unable to find a command");
            }
        }

杀死所有:

public HashMap killAll() throws XmlRpcFault {
            HashMap retHash = new HashMap();

            int length = instances.values().size();
            if (length > 0) {
                Set keys = instances.keySet();
                for (Object key : keys) {
                    retHash.put(key, killAllKiller(Integer.parseInt(key.toString())));
                }
                //Since we killed all procs, suggest a GC as well
                instances.clear();
                System.gc();


                return retHash;
            } else {
                throw new XmlRpcFault(404, "No processes running");
            }

        }

Answer 1

让我建议另一种选择

• 收到请求后，将命令和 ID 放入 Queue (包装在一个对象中)，并将id返回给用户
• 创建 ThreadPoolExecutor将从队列接收命令，执行它们并将结果放入 ConcurrentHashMap 中
• 然后，客户端将仅访问结果 map

这样，新的请求和结果之间就不会发生争用。

我会将此映射放在 servlet 上下文中，这是保存应用程序级变量的自然位置。