Java 细粒度锁

梦魇丿

已于 2024-02-23 15:07:45 修改

阅读量1k

点赞数 15

文章标签： java python 前端算法开发语言

于 2024-02-22 10:28:24 首次发布

本文链接：https://blog.csdn.net/qwert16576514/article/details/136245964

版权

问题背景：

最近在学习微信支付相关API，看到支付回调并发问题时，课程中用的 ReentrantLock 来实现支付结果回调防止重复写入支付信息。

问题出现的原因在于在用户完成支付的时候，微信官方会发起回调，通知系统处理订单（如修改订单信息、插入支付记录）。当一次支付成功时，微信会出现多次请求回调接口的情况，所以在处理回调的方法里面就要做好重复支付成功消息的处理。

要处理的问题如下：

当收到回调请求时，如果当前支付订单号已经是已支付状态（之前已经处理过回调），那么就无需处理订单，也不需要插入支付记录。
还要防止两个回调同时到达的并发问题（两个回调请求同时到达，同时判断订单信息为未支付），则会导致支付信息多插入一条的问题。

针对以上问题，课程视频中给出的方案是使用 ReentrantLock 加锁来实现

个人的思考：这样的锁粒度太大了，现在的需求是只控制同一个支付订单号的请求加锁就可以了，如果是所有的回调都加锁的话，显然会有性能问题。

这几天正好在学校并发编程相关知识，看到细粒度锁的几种实现：

分段锁
hash锁
弱引用锁

分段锁

在程序中预制 20 把锁（取决于要分片处理的数量）放入map中存放，0-19 ，在处理业务时根据业务id（支付订单ID）%20 取模，取获取 map 中的锁，这样就一定程度上避免了不同的业务id 获取到相同的锁，而影响性能了。

public class PaymentLogger {
    private ReentrantLock[] locks;


    public PaymentLogger(int segments) {
        locks = new ReentrantLock[segments];
        for (int i = 0; i < segments; i++) {
            locks[i] = new ReentrantLock();
        }
    }


    public void logPayment(int orderId, String paymentInfo) {
        int segment = orderId % locks.length;
        locks[segment].lock();
        try {
            
            if (isOrderPaid(orderId)) {
                System.out.println("Order " + orderId + " has already been paid. No need to log payment.");
            } else {
                
                recordPaymentLog(orderId, paymentInfo);
            }
        } finally {
            locks[segment].unlock();
        }
    }


    private boolean isOrderPaid(int orderId) {
        
        return false; 
    }


    private void recordPaymentLog(int orderId, String paymentInfo) {
        
        System.out.println("Recording payment log for order " + orderId + ": " + paymentInfo);
    }


    public static void main(String[] args) {
        PaymentLogger paymentLogger = new PaymentLogger(5); 
        
        for (int i = 0; i < 10; i++) {
            int orderId = i % 3; 
            String paymentInfo = "Payment " + i;
            new Thread(() -> {
                paymentLogger.logPayment(orderId, paymentInfo);
            }).start();
        }
    }
}

在这个示例中，我们创建了一个 PaymentLogger 类来记录支付日志。在构造函数中，我们创建了一定数量的分段锁，用于对不同的订单进行并发控制。在 logPayment 方法中，我们首先根据订单号选择对应的分段锁，然后对该分段锁进行加锁操作。在加锁后，我们检查订单状态，如果订单已经支付，则无需记录支付日志；否则，记录支付日志。最后，我们在 finally 块中释放分段锁。

在 main 方法中，我们模拟了并发情况下多次记录支付日志的情况，通过分段锁的控制，确保了对不同订单的并发处理

hash锁

分段锁和哈希锁都是用来解决并发访问共享资源的问题，但它们的应用场景和使用方式略有不同。

分段锁主要应用于对一组资源进行分段加锁，以提高并发性能。每个锁只锁定一部分数据，这样不同的线程可以同时访问不同的分段，从而减小了锁的粒度，提高了并发度。分段锁适用于对固定数量的资源进行并发控制，比如对数组、链表等数据结构进行并发访问时，可以根据索引或者哈希值选择不同的分段锁。

哈希锁则是根据资源的哈希值来选择锁，通常用于对动态数量的资源进行并发控制。在哈希锁中，资源的哈希值决定了锁的选择，不同的资源可能会被映射到不同的锁上。哈希锁适用于对动态数量的资源进行并发控制，比如对订单号、用户ID等动态资源进行并发访问时，可以根据哈希值选择相应的锁。

因此，分段锁适用于对固定数量的资源进行并发控制，而哈希锁适用于对动态数量的资源进行并发控制。在实际应用中，根据具体的场景和需求，可以选择合适的并发控制方式来保证数据的一致性和并发性能。

import java.util.concurrent.locks.ReentrantLock;


public class PaymentLogger {
    private ReentrantLock[] locks;


    public PaymentLogger(int capacity) {
        locks = new ReentrantLock[capacity];
        for (int i = 0; i < capacity; i++) {
            locks[i] = new ReentrantLock();
        }
    }


    public void logPayment(int orderId, String paymentInfo) {
        int hash = getHash(orderId); 
        locks[hash].lock();
        try {
            
            if (isOrderPaid(orderId)) {
                System.out.println("Order " + orderId + " has already been paid. No need to log payment.");
            } else {
                
                recordPaymentLog(orderId, paymentInfo);
            }
        } finally {
            locks[hash].unlock();
        }
    }


    private int getHash(int orderId) {
        return orderId % locks.length; 
    }


    private boolean isOrderPaid(int orderId) {
        
        return false; 
    }


    private void recordPaymentLog(int orderId, String paymentInfo) {
        
        System.out.println("Recording payment log for order " + orderId + ": " + paymentInfo);
    }


    public static void main(String[] args) {
        PaymentLogger paymentLogger = new PaymentLogger(5); 
        
        for (int i = 0; i < 10; i++) {
            int orderId = i % 3; 
            String paymentInfo = "Payment " + i;
            new Thread(() -> {
                paymentLogger.logPayment(orderId, paymentInfo);
            }).start();
        }
    }
}

在这个示例中，我们创建了一个 PaymentLogger 类来记录支付日志。在构造函数中，我们创建了一定数量的哈希锁，用于对不同的订单进行并发控制。在 logPayment 方法中，我们首先根据订单号计算哈希值，然后使用这个哈希值选择对应的哈希锁，对其进行加锁操作。在加锁后，我们检查订单状态，如果订单已经支付，则无需记录支付日志；否则，记录支付日志。最后，我们在 finally 块中释放哈希锁。

在 main 方法中，我们模拟了并发情况下多次记录支付日志的情况，通过哈希锁的控制，确保了对不同订单的并发处理。

弱引用锁

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;


public class WeakRefHashLock {
    private ConcurrentHashMap<Object, LockWeakReference> lockMap = new ConcurrentHashMap<>();
    private ReferenceQueue<ReentrantLock> queue = new ReferenceQueue<>();


    public ReentrantLock getLock(Object key) {
        clearEmptyRef();
        LockWeakReference weakRef = lockMap.get(key);
        ReentrantLock lock = (weakRef == null ? null : weakRef.get());


        while (lock == null) {
            weakRef = new LockWeakReference(key, new ReentrantLock(), queue);
            LockWeakReference existingRef = lockMap.putIfAbsent(key, weakRef);
            if (existingRef == null) {
                lock = weakRef.get();
            } else {
                lock = existingRef.get();
            }
        }
        return lock;
    }


    private void clearEmptyRef() {
        Reference<? extends ReentrantLock> ref;
        while ((ref = queue.poll()) != null) {
            LockWeakReference lockWeakReference = (LockWeakReference) ref;
            lockMap.remove(lockWeakReference.key);
        }
    }


    class LockWeakReference extends WeakReference<ReentrantLock> {
        private Object key;


        public LockWeakReference(Object key, ReentrantLock lock, ReferenceQueue<? super ReentrantLock> q) {
            super(lock, q);
            this.key = key;
        }
    }
}

在这个示例中，我们创建了一个 WeakRefHashLock 类来存储弱引用锁。在 getLock 方法中，我们首先调用 clearEmptyRef 方法来清除已被回收的弱引用对象。然后尝试从 lockMap 中获取对应 key 的锁对象，如果获取到则直接返回，否则创建一个新的弱引用锁对象并放入 lockMap 中。

在 LockWeakReference 类中，我们使用了弱引用来存储 ReentrantLock 对象，并且存储了对应的 key 值，方便在清除无用的引用时进行操作。

这样，通过使用弱引用锁，可以在锁不再被使用时自动释放锁资源，避免了锁被长时间持有导致的内存泄漏问题。同时，通过清理已被回收的弱引用对象，释放已经不再使用的锁资源。

需要注意的是，这种方式虽然可以避免内存泄漏问题，但在并发环境下需要谨慎使用，因为弱引用锁可能会导致在极端情况下锁对象被提前回收，从而导致并发问题。在实际开发中，建议仔细评估使用弱引用锁的风险，确保在并发环境下能正确地处理锁对象的回收和重新创建。

梦魇丿

关注

15
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java 细粒度锁

问题背景：最近在学习微信支付相关API，看到支付回调并发问题时，课程中用的 ReentrantLock 来实现支付结果回调防止重复写入支付信息。问题出现的原因在于在用户完成支付的时候，微信官方会发起回调，通知系统处理订单（如修改订单信息、插入支付记录）。当一次支付成功时，微信会出现多次请求回调接口的情况，所以在处理回调的方法里面就要做好重复支付成功消息的处理。要处理的问题如下：当收到回调请求时...
复制链接

扫一扫