java - 处理来自客户端的多个请求以更新 Spring 应用程序中表中的列

Question

我在该表中有一个名为 Balance 的表，我有员工和员工积分。

假设员工约翰同时使用移动和网络应用程序下订单。
因此，目前当他尝试从两个应用程序下订单时，应该相应地更新该点。
当他尝试同时下订单时，每个请求都会获得 5000 点，并根据 john 的购物车值(value)更新该点。
他从移动应用程序中兑换了 2000 积分，因此更新的金额为 5000-2000 即 3000
他从网络应用程序兑换了 1000 点，因此更新的金额应为 3000-1000，即 2000
但在当前场景中，更新的数量是 5000-1000 = 4000。(对于 Web 应用程序脏读)
我应该怎么做才能确保交易正确。
我已将隔离级别添加到 SERIALIZABLE 但在这种情况下，当第二个请求更新表列点时
我得到 org.springframework.dao.DeadlockLoserDataAccessException:
我应该怎么做才能确保同时请求以适当的点更新表格。
下面是我的代码

@Transactional(isolation=Isolation.SERIALIZABLE)
public void updatePoints(String employee,int points){
    Object[] arr = new Object[] {points, employeeId};
    getJdbcTemplate().update("UPDATE BALANCE SET POINTS =POINTS -? WHERE EMPLOYEEID=?",arr);
} 

请在代码上方查找更新代码仅用于理解目的
在服务层使用事务而不是在 dao 层

@Override
    @Transactional(isolation=Isolation.SERIALIZABLE)
    public void putFinalCartItems(String employeeCode, List<String> cartId, Map<String, Object> statusMap,int userId) {
        CartItems carPoints = repoDao.getFinalCartItems(cartId,employeeCode);//here i have used select query with join from Balance Table
        try {
        
            
            String orderNo=null;
            String mainOrderNo=OrderIdGenerator.getOrderId();
            List<CartItems> finalCartItems = repoDao.getBifurcatedFinalCart(cartId,employeeCode);//here i have used select query with join from Balance Table
            Integer balance = Integer.parseInt(finalCartItems.get(0).getPoints());
            Integer successCount=0;
            try {
                
                for(CartItems cartEntityId : finalCartItems) {
                    balance = balance-Integer.parseInt(cartEntityId.getTotalNoOfPoint());
        
                     orderNo="TRANS-"+cartEntityId.getId();
                     successCount = repoDao.placeOrder(cartEntityId);
                }
                repoDao.updatePoints(Integer.parseInt(carPoints.getTotalNoOfPoint()),userId,employeeCode);
            
            }catch(Exception e) {
                //e.printStackTrace();
                successCount=0;
            }
            if(successCount>0) {
                    FinalOrder lfo = new FinalOrder();
                    lfo.setBalance(String.valueOf(totbalance));
                    lfo.setMainOrderId(mainOrderNo);
                    lfo.setTotalPointsSpent(carPoints.getTotalNoOfPoint());
                    statusMap.put("success",lfo );
                    
            }
        }
        catch(Exception e ) {
            statusMap.put("error","Please try again after some time" );
        }
    }

我收到第二个请求的错误堆栈跟踪

org.springframework.dao.DeadlockLoserDataAccessException: PreparedStatementCallback; SQL [UPDATE BALANCE set Points=points-? where EMPLOYEEID=? ]; Transaction (Process ID 94) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.; nested exception is com.microsoft.sqlserver.jdbc.SQLServerException: Transaction (Process ID 94) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.
at org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator.doTranslate(SQLErrorCodeSQLExceptionTranslator.java:263)
at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:73)
at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:649)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:870)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:931)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:941)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:333)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:52)

我希望第二个请求与第一个请求同时成功，没有脏读。

Answer 1

Isolation.SERIALIZABLE对性能不利。异常名称具有误导性，因为它不是死锁，因为假设您没有其他一些 Isolation.SERIALIZABLE 以相同的顺序更新表方法。

死锁是当两个不同的并行操作尝试获取锁时。说 Txn1涉及更新 table a首先和table b第二。 Txn2涉及更新 table b首先和table a第二。现在，如果它们都并行运行，Txn1会锁table a并希望锁定 table b ，但是 Txn2已锁定，table b首先并希望锁定 table a先等对方放弃。但在你的例子中情况并非如此。因此，如果您仍想继续使用 Isolation.SERIALIZABLE ，你需要 catch DeadlockLoserDataAccessException并在当时重新计算点重试。

您的真实代码与最初的问题不同。在最初的问题中，您正在增加点数，但在实际代码中，您正在用新计算的点数替换这些点数。所以我想如果你在没有 Isolation.SERIALIZABLE 的情况下使用初始问题中的方法，它应该工作。

所以你需要传递给更新点方法的参数是pointsToReduct不是 newTotalPoints .

    Object[] arr = new Object[] { pointsToReduct, employeeId };
    getJdbcTemplate().update("UPDATE BALANCE SET POINTS = POINTS - ? WHERE 
                               EMPLOYEEID = ?",arr);