Spring事务可以取消同步同步方法吗？

Question

我和我的同事有一个 Web 应用程序，它在 MyEclipse 内的 Tomcat 上使用 Spring 3.0.0 和 JPA (hibernate 3.5.0-Beta2)。其中一种数据结构是树。只是为了好玩，我们尝试使用 JMeter 对“插入节点”操作进行压力测试，并发现了并发问题。 Hibernate 报告发现两个具有相同私钥的实体，紧接着出现这样的警告：

 WARN  [org.hibernate.engine.loading.LoadContexts] fail-safe cleanup (collections) : ...

如果多个线程同时调用 insert() 方法，很容易看出如何发生此类问题。

我的 servlet A 调用服务层对象 B.execute()，然后服务层对象调用较低层对象 C.insert()。 （真正的代码太大，无法发布，因此有所删节。）

Servlet A：

  public void doPost(Request request, Response response) {
    ...
    b.execute(parameters);
    ...
  }

服务 B：

  @Transactional //** Delete this line to fix the problem.
  public synchronized void execute(parameters) {
    log("b.execute() starting. This="+this);
    ...
    c.insert(params);
    ...
    log("b.execute() finishing. This="+this);
  }

子服务 C：

  @Transactional
  public void insert(params) {
    ...
    // data structure manipulation operations that should not be 
    // simultaneous with any other manipulation operations called by B.
    ...
  }

我所有的状态更改调用都经过 B，所以我决定使 B.execute() 同步。已经是@Transactional了，但实际上需要同步的是业务逻辑，而不仅仅是持久化，所以这看起来很合理。

我的 C.insert() 方法也是 @Transactional。但由于 Spring 中的默认事务传播似乎是必需的，因此我认为没有为 C.insert() 创建任何新事务。

所有组件 A、B 和 C 都是 spring-bean，因此都是单例。如果确实只有一个 B 对象，那么我得出的结论是，不可能同时有多个威胁执行 b.execute() 。当负载较轻时，只使用单线程，就是这种情况。但是在负载下，会涉及其他线程，并且我看到在第一个线程打印“完成”之前有几个线程打印“开始”。这似乎违反了该方法的同步性质。

我决定在日志消息中打印 this 来确认是否只有一个 B 对象。所有日志消息都显示相同的对象 ID。

经过大量令人沮丧的调查后，我发现删除 B.execute() 的 @Transactional 可以解决问题。这条线消失后，我可以拥有很多线程，但我总是看到一个“开始”，然后是“结束”，然后再下一个“开始”（并且我的数据结构保持不变）。不知何故，synchronized 似乎仅在 @Transactional 不存在时才起作用。但我不明白为什么。有人可以帮忙吗？关于如何进一步研究这个问题有什么建议吗？

在堆栈跟踪中，我可以看到在 A.doPost() 和 B.execute() 之间以及 B.execute() 和 C.insert() 之间生成了 aop/cglib 代理。我想知道代理的构造是否会以某种方式破坏同步行为。

Answer 1

问题在于@Transactional封装了synchronized方法。 Spring 使用 AOP 来实现这一点。
执行过程是这样的：

1. 启动事务
2. 当方法返回时调用带有 @Transactional 注释的方法
3. 提交事务

步骤 1. 和 3. 可以由多个线程同时执行。因此，您可以多次开始交易。

您唯一的解决方案是同步对方法本身的调用。

Answer 2

正如您所说，同步关键字要求涉及的对象始终相同。我自己没有观察到上述行为，但你的怀疑可能是正确的。

您是否尝试过从 doPost 方法中注销 b ？如果每次都不同，那么 AOP/cglib 代理就会发挥一些 Spring 魔力。

无论如何，我不会依赖 Synchronized 关键字，而是使用类似 ReentrantLock 来自 java.util.concurrent.locks 以确保同步行为，因为无论可能有多个 cglib 代理，您的 b 对象始终相同。

Answer 3

选项 1：

Delete synchronized of ServiceB and:

public void doPost(Request request, Response response) {
    ...
    synchronized(this)
    {
        b.execute(parameters);
    }
    ...
  }

选项 2：

Delete synchronized of ServiceB and:

public class ProxyServiceB (extends o implements) ServiceB
{
    private ServiceB serviceB;
    public ProxyServiceB(ServiceB serviceB)
    {
        this.serviceB =serviceB;
    }
    public synchronized void execute(parameters) 
    {
         this.serviceB.execute(parameters);
    }
} 

public void doPost(Request request, Response response) 
{
    ...
    ProxyServiceB proxyServiceB = new ProxyServiceB(b);
    proxyServiceB .execute(parameters);
    ...
}

Answer 4

选项 2 再次：

删除 ServiceB 的同步并且：

public class ProxyServiceB (extends o implements) ServiceB
{
    private ServiceB serviceB;
    public ProxyServiceB(ServiceB serviceB)
    {
        this.serviceB =serviceB;
    }
    public synchronized void execute(parameters) 
    {
         this.serviceB.execute(parameters);
    }
} 

public class TheServlet extends HttpServlet
{
   private static ProxyServiceB proxyServiceB = null;

   private static ProxyServiceB getProxyServiceBInstance()
   {
        if(proxyServiceB == null)
        {
            return proxyServiceB = new ProxyServiceB(b);
        }
        return proxyServiceB;
   }

   public void doPost(Request request, Response response) 
   {
    ...
     ProxyServiceB proxyServiceB = getProxyServiceBInstance();
    proxyServiceB .execute(parameters);
    ...
   }    
}