为每个线程创建一个非线程安全对象并使用happens-before保证

Question

我想将 SAAJ 中的 SOAPConnectionFactory 和 MessageFactory 类用于多线程，但事实证明我不能假设它们是线程安全的。 一些相关帖子：

• javax.xml.soap.MessageFactory's instance is thread-safe?
• jaxp object caching for MessageFactory

这是一个有趣的小证明，证明它可以是线程安全的： http://svn.apache.org/repos/asf/axis/axis2/java/core/tags/v1.5.6/modules/saaj/src/org/apache/axis2/saaj/SOAPConnectionImpl.java 据说

虽然 SAAJ 规范没有明确要求线程安全，但 Sun 参考实现中的 SOAPConnection 似乎是线程安全的。

但我仍然认为将 SAAJ 类视为线程安全的证据还不够。

所以我的问题是：下面的成语正确吗？我使用主线程内可能的非线程安全工厂创建了一个 SOAPConnection 和 MessageFactory 对象，然后使用 CompletionService 接口的happens-before保证将这些对象安全地发布到执行程序任务。我也使用这种发生前的保证来提取结果 HashMap 对象。

基本上我只是想验证我的推理是否合理。

public static void main(String args[]) throws Exception {
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    CompletionService<Map<String, String>> completionService = new ExecutorCompletionService<>(executorService);

    //submitting 100 tasks
    for (int i = 0; i < 100; i++) {
        // there is no docs on if these classes are thread-safe or not, so creating them before submitting to the
        // external thread. This seems to be safe, because we are relying on the happens-before guarantees of the
        // CompletionService.
        SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory.newInstance();
        SOAPConnection soapConnection = soapConnectionFactory.createConnection();
        MessageFactory messageFactory = MessageFactory.newInstance();
        int number = i;// we can't just use i, because it's not effectively final within the task below
        completionService.submit(() -> {
            // using messageFactory here!
            SOAPMessage request = createSOAPRequest(messageFactory, number);
            // using soapConnection here!
            SOAPMessage soapResponse = soapConnection.call(request, "example.com");
            soapConnection.close();
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            soapResponse.writeTo(outputStream);
            // HashMap is not thread-safe on its own, but we'll use the happens-before guarantee. See f.get() below.
            Map<String, String> result = new HashMap<>();
            result.put("soapResponse", new String(outputStream.toByteArray()));
            return result;

        });
    }

    // printing the responses as they arrive
    for (int i = 0; i < 100; i++) {
        Future<Map<String, String>> f = completionService.take();
        Map<String, String> result = f.get();
        System.out.println(result.get("soapResponse"));
    }

    executorService.shutdown();
}

/**
 * Thread-safe static method
 */
private static SOAPMessage createSOAPRequest(MessageFactory messageFactory, int number) throws Exception {
    SOAPMessage soapMessage = messageFactory.createMessage();
    SOAPPart soapPart = soapMessage.getSOAPPart();

    String serverURI = "example.com";

    SOAPEnvelope envelope = soapPart.getEnvelope();
    envelope.addNamespaceDeclaration("example", serverURI);

    SOAPBody soapBody = envelope.getBody();
    SOAPElement soapBodyElem = soapBody.addChildElement("number", "example");
    soapBodyElem.addTextNode(String.valueOf(number));

    soapMessage.saveChanges();

    return soapMessage;
}

Answer 1

我测试了你的代码，看起来你正在通过一个soapConnectionFactory 创建一个soapConnection，这非常好。 SAAJ 1.3 中的以下方法返回 MessageFactory 的新实例

public static MessageFactory newInstance(String protocol) throws SOAPException {
    return SAAJMetaFactory.getInstance().newMessageFactory(protocol);
}

在描述中没有关于线程安全的信息，但是通过查看代码，似乎这种方法主要使用堆栈变量，例如在堆栈中有一个 SOAPConnection 对象并使用它。如果soapConnection.call(request, "example.com") 被多个线程调用，尽管没有同步块，我看不到问题。

人们会期望线程会通过不同的连接发送它们的结果消息

Answer 2

我花了一个小时发现com.sun.xml.internal.messaging.saaj 的来源（用作Oracle JDK 中的默认SAAJ 实现）并发现WhateverFactory.newInstance() 返回的工厂都没有任何内部状态。所以它们绝对是线程安全的，不需要多次实例化。

这些工厂是：

• SOAPConnectionFactory -- client.p2p.HttpSOAPConnectionFactory
• MessageFactory -- soap.ver1_1.SOAPMessageFactory1_1Impl

例如，HttpSOAPConnectionFactory 在正文中实际上只有 3 行：

public class HttpSOAPConnectionFactory extends SOAPConnectionFactory {

    public SOAPConnection createConnection() throws SOAPException {
        return new HttpSOAPConnection();
    }
}

SOAPMessage 和SOAPConnection 怎么样——它们必须在一个线程中使用，尽管对它们进行的操作涉及多个调用。 （事实上，SOAPConnection#call() 也是线程安全的，因为 HttpSOAPConnection 除了 closed 变量之外不保存任何内部状态。它可以，但不应该被重用，除非你保证.close() 永远不会被调用，否则后续的.call() 将抛出。）处理完成后，SOAPConnection 应该被关闭并忘记，以及在特定请求-响应周期中使用的 SOAPMessage 实例。

总结：我相信你做的一切都是正确的，除了为每个调用创建单独的工厂。至少在上述实现中，这些工厂是完全线程安全的，因此您可以节省加载类的时间。

---

所有所说的都是指 Oracle JDK 附带的默认 SAAJ 实现。如果您使用的商业 Java EE 应用服务器（Websphere、JBoss 等）的实现可能是特定于供应商的，最好将您的问题提交给他们的支持。

Answer 3

是的，您对 CompletionService 的推理是正确的—— .submit() 确保任务 lambda 将看到完整的对象，而 .take() 确保主线程只会看到完整的响应。

不过，一般情况下，您不需要这样做。 static 工厂方法应该始终是线程安全的，因为在没有整个 JVM 全局知识的情况下，没有方法可以确保它们不会在其他线程中使用，并且您不能真正编写在许多环境中依赖于它的代码。但是，有时您会看到一个实现可能会出现问题，如果一个线程尝试使用它而另一个线程正在配置它，但即使这样也很少见。

想象一个使用 SOAPConnectionFactory 的 servlet。不可能知道同一 JVM 中没有其他 Web 应用程序没有同时使用它，因此它必须是线程安全的。

所以，实际上，如果 MessageFactory.newInstance() 和 SOAPConnectionFactory.newInstance() 不是线程安全的，它们就是错误的。我会在多个线程中使用它们而无需担心，如果您真的担心，只需检查源代码。但他们真的很好。

另一方面，由静态工厂方法创建的对象（甚至是其他工厂）通常不是线程安全的，您不应该假设它们没有说明文件的文档。即使检查源代码也不够，因为如果接口没有被记录为线程安全的，那么以后有人可以将不安全状态添加到实现中。