springboot高并发细粒度加锁(key粒度加锁)

- 日理万妓 2023-03-06 05:10 5阅读 0赞

1、场景：

设想，多线程对key=fusor:$\{order\_id\}并发访问触发了竞态条件，例如两个线程同时发现key=fusor:$\{order\_id\}的值为5，然后并且+1回写6，这个时候就出现了问题，最终的值为6而不是7。

2、粗粒度锁：

这时候，普遍的做法是加锁，但是如果对整个访问redis的动作加锁，那么等于多个线程串行访问了！

3、细粒度加锁：

我们这里的做法是对key进行细粒度加锁，每个key拥有一把锁，只对key进行并发控制，key与key之间允许并发。

4、细粒度代码

import org.springframework.stereotype.Component;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    import java.util.concurrent.Semaphore;
    
    @Component
    public class KeyLock<K> {
    	// 保存所有锁定的KEY及其信号量
    	private final ConcurrentMap<K, Semaphore> map = new ConcurrentHashMap<K, Semaphore>();
    	// 保存每个线程锁定的KEY及其锁定计数
    	private final ThreadLocal<Map<K, LockInfo>> local = new ThreadLocal<Map<K, LockInfo>>() {
    		@Override
    		protected Map<K, LockInfo> initialValue() {
    			return new HashMap<K, LockInfo>();
    		}
    	};
    
    	/**
    	 * 锁定key，其他等待此key的线程将进入等待，直到调用{@link #unlock(K)}
    	 * 使用hashcode和equals来判断key是否相同，因此key必须实现{@link #hashCode()}和
    	 * {@link #equals(Object)}方法
    	 *
    	 * @param key
    	 */
    	public void lock(K key) {
    		if (key == null)
    			return;
    		LockInfo info = local.get().get(key);
    		if (info == null) {
    			Semaphore current = new Semaphore(1);
    			current.acquireUninterruptibly();
    			Semaphore previous = map.put(key, current);
    			if (previous != null)
    				previous.acquireUninterruptibly();
    			local.get().put(key, new LockInfo(current));
    		} else {
    			info.lockCount++;
    		}
    	}
    
    	/**
    	 * 释放key，唤醒其他等待此key的线程
    	 * @param key
    	 */
    	public void unlock(K key) {
    		if (key == null)
    			return;
    		LockInfo info = local.get().get(key);
    		if (info != null && --info.lockCount == 0) {
    			info.current.release();
    			map.remove(key, info.current);
    			local.get().remove(key);
    		}
    	}
    
    	/**
    	 * 锁定多个key
    	 * 建议在调用此方法前先对keys进行排序，使用相同的锁定顺序，防止死锁发生
    	 * @param keys
    	 */
    	public void lock(K[] keys) {
    		if (keys == null){
    			return;
    		}
    		for (K key : keys) {
    			lock(key);
    		}
    	}
    
    	/**
    	 * 释放多个key
    	 * @param keys
    	 */
    	public void unlock(K[] keys) {
    		if (keys == null){
    			return;
    		}
    		for (K key : keys) {
    			unlock(key);
    		}
    	}
    
    	private static class LockInfo {
    		private final Semaphore current;
    		private int lockCount;
    
    		private LockInfo(Semaphore current) {
    			this.current = current;
    			this.lockCount = 1;
    		}
    	}
    }

5、细粒度锁的调用

private KeyLock<String> lock = new KeyLock<String>();
    
    public ReturnMsg addPatientList(PatientCrudReq patientCrudReq){
        ReturnMsg ss = new ReturnMsg();
        
        String key = patientCrudReq.getSyxh() + "_" + patientCrudReq.getYexh()
                     + "_" + patientCrudReq.getHzlxdm() ; //请求的主键（唯一标识）
    
        try {
            lock.lock(key);
            ss = iOutPutService.addPatientList(patientCrudReq, result);
        } finally {
            lock.unlock(key);
        }
    
        return ss;
    }

6、参照网址：

[https://cloud.tencent.com/developer/article/1050328][https_cloud.tencent.com_developer_article_1050328]

[https://blog.csdn.net/lyl117363/article/details/84395377?utm\_medium=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase&depth\_1-utm\_source=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase][https_blog.csdn.net_lyl117363_article_details_84395377_utm_medium_distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase_depth_1-utm_source_distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase]

[https_cloud.tencent.com_developer_article_1050328]: https://cloud.tencent.com/developer/article/1050328
[https_blog.csdn.net_lyl117363_article_details_84395377_utm_medium_distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase_depth_1-utm_source_distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase]: https://blog.csdn.net/lyl117363/article/details/84395377?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-8.nonecase