java key 粒度加锁工具，有考虑其他如redis锁切换扩展

最新推荐文章于 2023-10-16 21:05:20 发布
最新推荐文章于 2023-10-16 21:05:20 发布
阅读量808 收藏
点赞数
分类专栏： 工具 文章标签： java lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g5zhu5896/article/details/121385787
版权

 首先是key粒度的加锁工具

第一种实现：

public class ReentrantKeyLock {


    public Lock getLock(String lockKey) {
        Assert.notNull(lockKey, "lockKey不能为空");
        return new KeyLock(lockKey);
    }

    public static class KeyLock implements Lock, java.io.Serializable {

        //lockKey和对应的锁信息集合
        private static final Map<String, LockInfo> LOCK_INFO_MAP = Maps.newHashMap();

        private final String lockKey;

        public KeyLock(String lockKey) {
            this.lockKey = lockKey;
        }

        @Override
        public void lock() {
            while (true) {
                LockInfo lockInfo = getLockInfo(lockKey);
                lockInfo.lockCount.incrementAndGet();
                lockInfo.lock.lock();
                //如果锁以失效则重新找lockKey对应的新锁加锁
                if (!lockInfo.isValid) {
                    lockInfo.lock.unlock();
                } else {
                    break;
                }
            }

        }

        @Override
        public void lockInterruptibly() throws InterruptedException {
            while (true) {
                LockInfo lockInfo = getLockInfo(lockKey);
                lockInfo.lockCount.incrementAndGet();
                lockInfo.lock.lockInterruptibly();
                //如果锁以失效则重新找lockKey对应的新锁加锁
                if (!lockInfo.isValid) {
                    lockInfo.lock.unlock();
                } else {
                    break;
                }
            }
        }

        @Override
        public boolean tryLock() {
            while (true) {
                LockInfo lockInfo = getLockInfo(lockKey);
                lockInfo.lockCount.incrementAndGet();
                boolean isSuccess = lockInfo.lock.tryLock();
                //如果锁以失效则重新找lockKey对应的新锁加锁
                if (isSuccess && !lockInfo.isValid) {
                    lockInfo.lock.unlock();
                } else {
                    return isSuccess;
                }
            }
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            while (true) {
                LockInfo lockInfo = getLockInfo(lockKey);
                lockInfo.lockCount.incrementAndGet();
                boolean isSuccess = lockInfo.lock.tryLock(time, unit);
                //如果锁以失效则重新找lockKey对应的新锁加锁
                if (isSuccess && !lockInfo.isValid) {
                    lockInfo.lock.unlock();
                } else {
                    return isSuccess;
                }
            }
        }

        @Override
        public void unlock() {
            LockInfo lockInfo = getLockInfo(lockKey);
            int lockCount = lockInfo.lockCount.decrementAndGet();
            if (lockCount == 0) {
                //如果加锁线程数为 0 则从LOCK_INFO_MAP移除对应的锁
                LOCK_INFO_MAP.remove(lockKey);
                lockInfo.isValid = false;
            }
            lockInfo.lock.unlock();
        }

        @Override
        public Condition newCondition() {
            return getLockInfo(lockKey).lock.newCondition();
        }

        private LockInfo getLockInfo(String lockKey) {
            LockInfo lockInfo = LOCK_INFO_MAP.get(lockKey);
            if (Objects.isNull(lockInfo)) {
                synchronized (LOCK_INFO_MAP) {
                    lockInfo = LOCK_INFO_MAP.get(lockKey);
                    if (Objects.isNull(lockInfo)) {
                        lockInfo = new LockInfo();
                        LOCK_INFO_MAP.put(lockKey, lockInfo);
                    }
                }
            }
            return lockInfo;
        }
    }

    private static class LockInfo {
        private final AtomicInteger lockCount;
        private final ReentrantLock lock;
        //如果 LockInfo 从 LOCK_INFO_MAP 移除则被改为 false ,表示该锁已经失效
        private boolean isValid = true;

        public LockInfo() {
            lockCount = new AtomicInteger();
            lock = new ReentrantLock();
        }
    }
}

第二种实现：思路是从Stack Overflow某人回答来的.大体代码和他类似

public class ReentrantKeyLock1 {

    public Lock getLock(String lockKey) {
        Assert.notNull(lockKey, "lockKey不能为空");
        return new KeyLock(lockKey);
    }

    public static class KeyLock implements Lock, java.io.Serializable {

        //lockKey和对应的锁信息集合
        private static final Map<String, LockInfo> LOCK_INFO_MAP = Maps.newConcurrentMap();

        private final String lockKey;

        public KeyLock(String lockKey) {
            this.lockKey = lockKey;
        }

        @Override
        public void lock() {
            LockInfo lockInfo = getLockInfo(true);
            lockInfo.lock.lock();
        }

        @Override
        public void lockInterruptibly() throws InterruptedException {
            LockInfo lockInfo = getLockInfo(true);
            lockInfo.lock.lockInterruptibly();
        }

        @Override
        public boolean tryLock() {
            LockInfo lockInfo = getLockInfo(true);
            boolean isSuccess = lockInfo.lock.tryLock();
            if (!isSuccess) {
                cleanCacheLock(lockInfo);
            }
            return isSuccess;
        }

        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            LockInfo lockInfo = getLockInfo(true);
            boolean isSuccess = lockInfo.lock.tryLock(time, unit);
            if (!isSuccess) {
                cleanCacheLock(lockInfo);
            }
            return isSuccess;
        }

        @Override
        public void unlock() {
            LockInfo lockInfo = getLockInfo(false);
            lockInfo.lock.unlock();
            cleanCacheLock(lockInfo);
        }

        @Override
        public Condition newCondition() {
            return getLockInfo(false).lock.newCondition();
        }


        /**
         * 清除 LOCK_MAP_INFO 里 lockKey 对应的数据
         * 需要从 LOCK_INFO_MAP 中移除 key ,并把 currentLockInfo 设为null
         *
         * @param lockInfo
         */
        private void cleanCacheLock(LockInfo lockInfo) {
            //只有当加锁次数为 0 时才清除锁信息
            if (lockInfo.lockCount.decrementAndGet() == 0) {
                LOCK_INFO_MAP.compute(lockKey, (key, cacheLockInfo) -> {
                    if (cacheLockInfo == null || cacheLockInfo.lockCount.get() == 0) {
                        return null;
                    }
                    return cacheLockInfo;
                });
            }
        }

        /**
         * 获取锁信息
         *
         * @param isLock 为 true 时,加锁次数+1
         * @return LockInfo
         */
        private LockInfo getLockInfo(boolean isLock) {
            if (isLock) {
                //currentLockInfo不存在就要创建锁,get and put 非原子操作所以需要加synchronized
                return LOCK_INFO_MAP.compute(lockKey, (key, lockInfo) -> {
                    if (lockInfo == null) {
                        lockInfo = new LockInfo();
                    }
                    lockInfo.lockCount.incrementAndGet();
                    return lockInfo;
                });
            } else {
                LockInfo lockInfo = LOCK_INFO_MAP.get(lockKey);
                Assert.notNull(lockInfo, "可能是由于没有执行 lock 操作");
                return lockInfo;
            }
        }

        private static class LockInfo {
            private final AtomicInteger lockCount;
            private final ReentrantLock lock;

            public LockInfo() {
                lockCount = new AtomicInteger();
                lock = new ReentrantLock();
            }
        }
    }
}

 上面两种不一样的地方主要是用于判断是否要从map中释放key的lockCount的自增点不一样。

下面的类主要是为了方便后面切换成redis或其他锁时不需要所有地方的代码都要改

LockManager接口：可以有不同的实现类返回redis的lock、zookeeper的lock或上面实现的ReentrantKeyLock

public interface LockManager {

    /**
     * 获取锁
     *
     * @param key 需要锁的key
     * @return
     */
    Lock getLock(String key);

}

KeyLockManager：返回 ReentrantKeyLock的Lock对于的LockManager

public class KeyLockManager implements LockManager {

    private ReentrantKeyLock reentrantKeyLock = new ReentrantKeyLock();

    @Override
    public Lock getLock(String key) {
        Assert.notNull(key, "key不能为空");
        Lock lock = reentrantKeyLock.getLock(key);
        return lock;
    }

}

 工厂类：

public class LockFactory {

    private static LockManager lockManager;

    public static void initLockManager(LockManager lockManager) {
        Assert.isNull(LockFactory.lockManager, "lockManager只能初始化一次");
        synchronized (LockFactory.class) {
            Assert.isNull(LockFactory.lockManager, "lockManager只能初始化一次");
            LockFactory.lockManager = lockManager;
        }
    }

    public static Lock getLock(String key) {
        Assert.notNull(lockManager, "请初始化lockManager");
        return lockManager.getLock(key);
    }
}

在spring中的使用示例

    @Bean
    public LockManager lockManager() {
        //后面只要此处改成Redis对应的LockManager,就可以切换成redis的分布式锁.
        LockManager lockManager = new KeyLockManager();
        LockFactory.initLockManager(lockManager);
        return lockManager;
    }


    public void test() {
        Lock keyA = LockFactory.getLock("keyA");
        keyA.lock();
        System.out.println(123);
        keyA.unlock();
    }

当然也可以在其他生命周期创建,比如CommandListen等

测试类

public class LockTest {

    public static void main(String[] args) {
        LockManager lockManager = new KeyLockManager();
        LockFactory.initLockManager(lockManager);
        Lock keyA = LockFactory.getLock("keyA");
        Lock keyB = LockFactory.getLock("keyB");
        Lock keyC = LockFactory.getLock("keyC");
        Lock keyD = LockFactory.getLock("keyD");
        Lock keyE = LockFactory.getLock("keyE");
        for (int i = 0; i <= 100000; i++) {
            new MyThread("keyA", "keyA线程" + i, keyA).start();
            new MyThread("keyB", "keyB线程" + i, keyB).start();
            new MyThread("keyC", "keyC线程" + i, keyC).start();
            new MyThread("keyD", "keyD线程" + i, keyD).start();
            new MyThread("keyE", "keyE线程" + i, keyE).start();
        }
//        new MyThread("keyA", "keyA线程1").start();
//        new MyThread("keyA", "keyA线程2").start();
//        new MyThread("keyB", "keyB线程1").start();
//        new MyThread("keyB", "keyB线程2").start();
    }

    static void sleep(int time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class MyThread extends Thread {
        private String key;
        private String name;
        static Long start = System.currentTimeMillis();

        private Lock lock;

        public MyThread(String key, String name, Lock lock) {
            super(name);
            this.key = key;
            this.name = name;
            this.lock = lock;

        }

        @SneakyThrows
        @Override
        public void run() {
//            Lock lock = LockFactory.getLock(key);
            lock.lock();
            try {
                System.out.println(name + "开始执行 key:" + key);
                Long time = (System.currentTimeMillis() - start) / 1000;
                System.out.println(name + "开始释放 key:" + key + "时间:" + time);

            } finally {
                lock.unlock();
            }

        }
    }
}

如果不考虑从Map中释放key对应的锁,下面有更简单的实现.

 

public class JdkLockManager implements LockManager {

    private Map<Object, Lock> LOCK_MAP = Maps.newHashMap();

    private boolean fair;

    public JdkLockManager() {
        this.fair = false;
    }

    public JdkLockManager(boolean fair) {
        this.fair = fair;
    }

    @Override
    public Lock getLock(String key) {
        Assert.notNull(key, "key不能为空");
        Lock lock = LOCK_MAP.get(key);
        if (Objects.isNull(lock)) {
            synchronized (this) {
                lock = LOCK_MAP.get(key);
                if (Objects.isNull(lock)) {
                    lock = newLock();
                    //如果key已经无用就需要考虑从 LOCK_MAP 释放 key 对应的锁防止内存泄露
                    LOCK_MAP.put(key, lock);
                }
            }
        }
        return lock;
    }

    private Lock newLock() {
        return new ReentrantLock(fair);
    }
}

g5zhu5896
关注
专栏目录
Redis——Redis的扩展与应用
庄小焱
04-02 1503
Redis 和 Memcached 的区别？ Redis的高级的数据结构 String、Hash、List、Set、SortedSet。HyperLogLog、Geo、Pub/Sub。那你说还玩过Redis Module，像BloomFilter，RedisSearch，Redis-ML 避免缓存穿透的利器之BloomFilter 如果有大量的key需要设置同一时间过期，一般需要注意什么？ 如果大量的key过期时间设置的过于集中，到过期的那个时间点，Redis可能会出现短暂的卡顿现象。严重的.
Redis框架从入门到学精（全）
码农研究僧的博客
07-02 2万+
目录前言1.NoSQL2.Redis2.1 软件安装数据类型 前言 解决功能新问题：JAVA jsp rdsms tomcat html linux jdbc svn 解决发展性问题：strtus spring springmvc hibernate mybatis 解决性能问题：NOSQL java 线程 hadoop nginx mq elasticsearch 1.NoSQL NoSQL特点 非关系型数据库，不依赖业务逻辑数据库存储，以简单key-value存储 适用于 ~高并发读写 ~海量数据读
Java单服务加锁工具类
05-24
Java加锁工具类。用于普通加锁。 可以用到的场景有： 1、多线程对同一数据进行处理时，通过此类进行简单加锁。 2、想保证后台同时，只有一个线程在处理某事情时。 3、更新数据库信息时。
JAVA细粒度、互斥KEY锁 —— KeyLock
zhengqiqiqinqin的专栏
11-10 3993
原文地址：http://blog.csdn.net/icebamboo_moyun/article/details/9391915 java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY（主键）的
java key锁_java中的锁
weixin_27155667的博客
02-16 225
引言在java单线程中，并不会出现资源抢夺的现象，但是在多线程并发中，会出现资源抢夺现象。为了避免这种情况需要上锁分类可重入锁，又名递归锁指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。使用synchronizedclass Phone{public v...
java实现key锁 对字符串key加同步锁或超时锁
最新发布
weixin_40452750的博客
10-16 616
java实现key锁 对字符串key加同步锁或超时锁
java key锁_java锁
weixin_35757191的博客
02-16 348
简介:锁一般来说用作资源控制，限制资源访问，防止在并发环境下造成数据错误1.重入锁目的：避免死锁的现象锁作为并发共享数据，保证一致性的工具，在java平台有多种实现synchronized(重量级)和ReentrantLock(轻量级)等等，这些已经写好提供的锁为我们开发提供了便利；重入锁：也叫作递归所，指的是同一线程外层函数获得锁之后，内层递归函数仍然有取该锁的代码，但不受影响；；在java环境...
说说Redis分布式锁是如何实现的。含Redis面试专题及答案
m0_67322837的博客
04-18 1631
前言 近来，分布式的问题被广泛提及，比如分布式事务、分布式框架、ZooKeeper、SpringCloud等等。本文先回顾锁的概念，再介绍分布式锁，以及如何用Redis来实现分布式锁。 一、锁的基本了解 首先，回顾一下我们工作学习中的锁的概念。 为什么要先讲锁再讲分布式锁呢？ 我们都清楚，锁的作用是要解决多线程对共享资源的访问而产生的线程安全问题，而在平时生活中用到锁的情况其实并不多，可能有些朋友对锁的概念和一些基本的使用不是很清楚，所以我们先看锁，再深入介绍分布式锁。 通过一个卖票的小案例来看
用万字长文来讲讲本地锁至分布式锁的演进和Redis实现，扩展 Redlock 红锁
Huangjiazhen711的博客
10-21 450
本地锁失效是因为无法锁住各个应用的读写请求，失效的根本原因就是其他的服务无法感知到是否已经有请求上锁了，即无法共享锁信息。分布式锁，其实也就是将加锁的这一个操作，单独的抽取出来了，让每个服务都能感知到。之前就说了，软件架构设计中，“没有什么是加一层解决不了的，如果加一层不行就再加一层”。这里其实也是一样，只不过碰巧这一层可以在Redis中实现罢了，看起来倒是没有多加一层，但如果是用Zookeeper或者其他方式来实现，你会发现架构中会多一层滴。其实理解思想实现的方式有很多种的，
redis的五种数据类型
热门推荐
学Java，找哪吒
05-15 5万+
（1）Redis（Remote Dictionary Server 远程字段服务）是一个开源的使用ANSI C语言编写、支持网络、科技与内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。（2）Redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string、list、set、zset（sorted set --有序集合）和hash。这些数据结构都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
java key锁_【转】JAVA细粒度、互斥KEY锁 —— KeyLock
weixin_29955689的博客
02-16 470
java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY(主键)的互斥锁，具有更细的粒度，在缓存或其他基于KEY的场景中有很大的用处。下面将讲解这个锁的设计和实现设想这么一个场景：转账private int[...
java key锁_java 常用锁
weixin_34220029的博客
02-16 344
公平锁和非公平锁1.公平锁，是指多个线程按照申请的顺序来获取锁，类似排队打饭，先来后到。2.非公平锁，是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发情况下，有可能会造成优先级反转或者饥饿现象。Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁，非公平锁的优点在于吞吐量比公平锁大。对于Synchronize...
java名称_简单的基于Java名称的锁？
weixin_30914901的博客
02-20 194
MySQL具有方便的功能：SELECT GET_LOCK("SomeName")这可用于为应用程序创建简单的但非常特定的基于名称的锁。但是，它需要数据库连接。我有很多情况，例如：someMethod() {// do stuff to user A for their data for feature X}简单地同步此方法是没有意义的，因为，例如，如果在此期间同时为用户B调用此方法，则用户B无需等...
Java 根据某个 key 加锁的实现方式
明明如月的技术博客
03-15 3181
日常开发中，有时候需要根据某个 key 加锁，确保多线程情况下，对该 key 的加锁和解锁之间的代码串行执行。 大家可以借助每个 key 对应一个 ReentrantLock ，让同一个 key 的线程使用该 lock 加锁；每个 key 对应一个 Semaphore ，让同一个 key 的线程使用 Semaphore 控制同时执行的线程数。
java key锁_JAVA细粒度、互斥KEY锁 —— KeyLock | 学步园
weixin_31992237的博客
02-13 484
java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。本文实现了一个基于KEY(主键)的互斥锁，具有更细的粒度，在缓存或其他基于KEY的场景中有很大的用处。下面将讲解这个锁的设计和实现设想这么一个场景：转账privateint[]...
java key锁_java细粒度锁
weixin_36337823的博客
02-16 932
Java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。下面来提供几个更细的粒度锁：1. 分段锁借鉴concurrentHashMap的分段思想，先生成一定数量的锁，具体使用的时候再根据key来返回对应的lock。这是几个实现里最简...
java的keylock_深入理解Java中的锁（三）
weixin_39613712的博客
02-24 318
ReadWriteLock接口读写锁维护一对关联锁，一个只用于读操作，一个只用于写操作。读锁可以由多个线程同时持有，又称共享锁。写锁同一时间只能由一个线程持有，又称互斥锁。同一时间，两把锁不能被不同线程持有。读写锁适合读取操作多于写入操作的场景，改进互斥锁的性能，比如集合的并发安全性改造，缓存组件等。ReentrantReadWriteLock实现原理分析ReentrantReadWriteLoc...
Java的锁机制
LittleSkey的博客
08-08 397
java对象锁的机制
通过key上锁，优化 jvm Lock
weixin_53632689的博客
06-22 360
减小锁粒度
redis 加锁解锁 java
09-21
在Java中，我们可以使用Redisson来实现对Redis的加锁和解锁操作。通过RedissonLock对象，我们可以获取锁的实例并进行相关操作。 要加锁，我们可以使用如下代码： ```java RLock lock = client.getLock("lock1"); //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值