public void updateWithRetry(int maxRetries) {
    int retries = 0;
    while (retries < maxRetries) {
        try {
            // 执行数据库操作
            updateData();
            return;
        } catch (DeadlockLoserDataAccessException e) {
            retries++;
            if (retries >= maxRetries) {
                throw e;
            }
            // 随机延迟后重试
            Thread.sleep((long)(Math.random() * 100));
        }
    }
}

// 按照ID排序，统一锁定顺序
List<Integer> ids = Arrays.asList(2, 1, 3);
ids.sort(Integer::compareTo);  // 排序

for (Integer id : ids) {
    updateById(id);
}

// 获取锁
String lockKey = "lock:resource:1";
String lockValue = UUID.randomUUID().toString();
Boolean acquired = redisTemplate.opsForValue()
    .setIfAbsent(lockKey, lockValue, 30, TimeUnit.SECONDS);

try {
    // 业务逻辑
    if (acquired) {
        // 处理业务
    }
} finally {
    // 释放锁（需要检查lockValue）
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                    "return redis.call('del', KEYS[1]) else return 0 end";
    redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
                         Collections.singletonList(lockKey), lockValue);
}

// 按照ID排序锁定
List<Integer> ids = getIdsToUpdate();
ids.sort(Integer::compareTo);  // 排序

for (Integer id : ids) {
    updateById(id);
}

// 快速提交
try {
    connection.setAutoCommit(false);
    // 只做必要的操作
    updateData();
    connection.commit();  // 尽快提交
} catch (SQLException e) {
    connection.rollback();
} finally {
    connection.setAutoCommit(true);
}

// 使用分布式锁
public void updateWithLock(String resourceId) {
    String lockKey = "lock:" + resourceId;
    if (distributedLock.tryLock(lockKey, 10, TimeUnit.SECONDS)) {
        try {
            // 业务逻辑
            updateResource(resourceId);
        } finally {
            distributedLock.unlock(lockKey);
        }
    }
}

@Retryable(value = {DeadlockLoserDataAccessException.class}, 
           maxAttempts = 3, 
           backoff = @Backoff(delay = 100))
public void updateWithRetry() {
    // 数据库操作
}

// 批量更新，减少锁竞争
public void batchUpdate(List<Integer> ids) {
    // 分批处理
    int batchSize = 100;
    for (int i = 0; i < ids.size(); i += batchSize) {
        List<Integer> batch = ids.subList(i, 
            Math.min(i + batchSize, ids.size()));
        updateBatch(batch);
    }
}

@Component
public class DistributedLock {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean tryLock(String key, String value, long expireTime) {
        Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(key, value, expireTime, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(result);
    }
    
    public void unlock(String key, String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "return redis.call('del', KEYS[1]) else return 0 end";
        redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key),
            value
        );
    }
}

public class ZookeeperLock {
    private CuratorFramework client;
    
    public InterProcessMutex acquireLock(String path) {
        InterProcessMutex lock = new InterProcessMutex(client, path);
        try {
            lock.acquire(10, TimeUnit.SECONDS);
            return lock;
        } catch (Exception e) {
            throw new RuntimeException("获取锁失败", e);
        }
    }
}

@Service
@Transactional(
    isolation = Isolation.READ_COMMITTED,
    propagation = Propagation.REQUIRED,
    timeout = 5,
    rollbackFor = Exception.class
)
public class UserService {
    public void updateUser(User user) {
        // 业务逻辑
    }
}

@Service
public class OrderService {
    @Autowired
    private DistributedLock distributedLock;
    
    public void createOrder(Order order) {
        // 按照用户ID排序锁定
        String lockKey = "lock:user:" + order.getUserId();
        String lockValue = UUID.randomUUID().toString();
        
        if (distributedLock.tryLock(lockKey, lockValue, 10)) {
            try {
                // 1. 扣减库存
                reduceStock(order.getProductId(), order.getQuantity());
                
                // 2. 扣减余额
                reduceBalance(order.getUserId(), order.getAmount());
                
                // 3. 创建订单
                saveOrder(order);
            } finally {
                distributedLock.unlock(lockKey, lockValue);
            }
        } else {
            throw new BusinessException("系统繁忙，请稍后重试");
        }
    }
}

@Service
public class TransferService {
    public void transfer(int fromAccountId, int toAccountId, BigDecimal amount) {
        // 统一锁定顺序：按照账户ID排序
        int firstLock = Math.min(fromAccountId, toAccountId);
        int secondLock = Math.max(fromAccountId, toAccountId);
        
        // 先锁小ID，再锁大ID
        lockAccount(firstLock);
        try {
            lockAccount(secondLock);
            try {
                // 执行转账
                deductBalance(fromAccountId, amount);
                addBalance(toAccountId, amount);
            } finally {
                unlockAccount(secondLock);
            }
        } finally {
            unlockAccount(firstLock);
        }
    }
}