如何多线程使用net.sf.saxon.s9api.XsltTransformer保障性能与吞吐量？

你当前的单例+全局同步方案本质是所有请求串行执行——因为唯一的XsltTransformer实例被全局锁保护，每个请求都要等前面的请求释放锁才能执行，这直接限制了吞吐量，是性能上不去的核心原因。

根据Saxon官方文档，XsltExecutable是线程安全的，可以在多线程环境中共享；而每个XsltExecutable.load()会生成独立的XsltTransformer实例（非线程安全，但可被单个线程重复使用）。基于这个特性，我们可以通过以下方案优化：

1. 重构单例类，持有线程安全的XsltExecutable #

把原来的XsltTransformer单例替换为XsltExecutable单例，只初始化一次，后续反复生成独立的Transformer实例：

public class XsltExecutableSingleton {
    private static XsltExecutable xsltExecutable;

    private XsltExecutableSingleton() {}

    public static void init() {
        if (xsltExecutable == null) {
            synchronized (XsltExecutableSingleton.class) {
                if (xsltExecutable == null) {
                    try {
                        Processor processor = new Processor(false);
                        XsltCompiler compiler = processor.newXsltCompiler();
                        xsltExecutable = compiler.compile(new StreamSource("/my_path/your-stylesheet.xsl"));
                    } catch (Exception e) {
                        throw new RuntimeException("初始化XsltExecutable失败", e);
                    }
                }
            }
        }
    }

    public static XsltExecutable getXsltExecutable() {
        if (xsltExecutable == null) {
            init();
        }
        return xsltExecutable;
    }
}

2. 使用对象池管理XsltTransformer实例 #

频繁创建XsltTransformer会有开销，用对象池复用实例可以平衡资源消耗和并行能力。这里以Apache Commons Pool2为例：

引入依赖（Maven） #

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.12.0</version>
</dependency>

实现对象池配置与工厂 #

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

public class XsltTransformerPool {
    private static GenericObjectPool<XsltTransformer> pool;

    static {
        // 配置对象池参数，根据服务器资源调整
        GenericObjectPoolConfig<XsltTransformer> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(100); // 最大实例数，建议参考CPU核心数*2或请求峰值
        poolConfig.setMaxIdle(50);   // 最大空闲实例数
        poolConfig.setMinIdle(10);   // 最小空闲实例数

        // 创建Transformer实例工厂
        BasePooledObjectFactory<XsltTransformer> factory = new BasePooledObjectFactory<>() {
            @Override
            public XsltTransformer create() throws Exception {
                return XsltExecutableSingleton.getXsltExecutable().load();
            }

            @Override
            public PooledObject<XsltTransformer> wrap(XsltTransformer transformer) {
                return new DefaultPooledObject<>(transformer);
            }

            // 归还实例时重置状态，确保下次使用干净
            @Override
            public void passivateObject(PooledObject<XsltTransformer> p) throws Exception {
                XsltTransformer transformer = p.getObject();
                transformer.setSource(null);
                transformer.setDestination(null);
            }
        };

        pool = new GenericObjectPool<>(factory, poolConfig);
    }

    public static XsltTransformer borrowTransformer() throws Exception {
        return pool.borrowObject();
    }

    public static void returnTransformer(XsltTransformer transformer) {
        pool.returnObject(transformer);
    }
}

3. 修改业务调用逻辑 #

每个请求独立从对象池获取Transformer实例，并行处理，无需全局同步：

public static void processXml(String xml) {
    XsltTransformer transformer = null;
    try {
        // 从对象池获取Transformer
        transformer = XsltTransformerPool.borrowTransformer();
        
        try (ByteArrayInputStream inputStream = new ByteArrayInputStream(xml.getBytes())) {
            transformer.setSource(new StreamSource(inputStream));
            XdmDestination result = new XdmDestination();
            transformer.setDestination(result);
            transformer.transform();
            
            // 处理转换后的结果
            // XdmNode output = result.getXdmNode();
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 归还Transformer到对象池
        if (transformer != null) {
            XsltTransformerPool.returnTransformer(transformer);
        }
    }
}

额外优化建议 #

• 调整对象池参数：根据服务器CPU核心数、内存和请求峰值调整MaxTotal，避免过多线程上下文切换。
• 复用Processor：Processor是线程安全的，可将其也做成单例，减少重复创建的开销。
• 优化XSLT样式表：检查是否存在低效的XPath表达式、不必要的节点遍历，或启用Saxon的流式处理（xsl:mode streamable="yes"，适合大XML场景）。
• JVM调优：增加堆内存（-Xmx）、使用G1GC等低停顿垃圾回收器，减少GC对性能的影响。
• 异步处理：如果业务允许，将XML转换任务放到异步线程池，进一步提升吞吐量。

内容的提问来源于stack exchange，提问作者AceCoder