分布式锁实现方法

最新推荐文章于 2021-10-13 11:31:11 发布

耳听代码

最新推荐文章于 2021-10-13 11:31:11 发布

阅读量133

点赞数 1

文章标签： redis 分布式 java

本文链接：https://blog.csdn.net/weixin_36802143/article/details/104839740

版权

场景

有两台client1和client2 并发的修改一个user表的数据,如果是数据库集群,client1 要修改user1的金额为20,client2要在20的基础上再加30,也就是要得到money=50的结果,这时如果没有分布式锁,可能出现的结果就是client1修改成功,数据库集群同步为20 ,之后client2修改成功集群整体修改为money=30
分布式锁的要求

提供阻塞和非阻塞的获取锁接口
锁超时自动释放
锁超时被其他客户端获取后，原来的锁持有者不能释放锁

1.zookeeper实现分布式锁

场景与原理:比如我们有三台机器,server1,server2,server3 ,这三台机器有一个zookeeper集群,两从(follower)一主(leader).
加锁
分布式锁的阻塞式获取,其实就是锁资源的并发竞争,在zk的视角里,就是对同一个path对应的ZNode的竞争创建.
zk的进程间同步的特性保证的同一时间,只有有一个client成功创建节点,其他client都会创建失败并提示NodeExist.
当client收到NodeExist的提示时,说明自己加锁没有成功,则此时需要进行锁等待,只要利用zk的watch机制监控锁对应的ZNode变更,
来唤醒等待线程,进行加锁重试,即可完成整个加锁流程.
第一个client1加锁成功后,client先获取这个znode节点,如果获取成功了就等待
锁的释放分两种情况:
1.client宕机,server检测不到心跳,则当达到会话超时时间时,server中的SessionTracker会自动删除会话,并同时删除该会话创建的所有临时节点,从而锁节点被释放(利用zk的临时节点特性)
2.client在执行完业务逻辑后,主动进行锁释放,其实就是主动调用delete进行节点删除
粗略的代码实现如下(只为了验证zk的特性,因此很多异常处理的逻辑被省略掉了)

public class LockDemo {

    /**
     * zk实现的分布式锁
     */
    public static class ZooKeeperLock implements Watcher {

        private static final Logger LOG = LoggerFactory.getLogger(com.lixin.lock.ZooKeeperLock.class);

        private static final String LOCK_PATH = "/lock";

        private ZooKeeper client = new ZooKeeper("172.18.212.149:2189", 60000, this, false);
        private Object lock = new Object();

        public ZooKeeperLock() throws IOException {
            while (!client.getClientState().isConnected()) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    LOG.error("", e);
                }
            }
        }

        public void lock() throws Exception {
            boolean success = false;
            while (!success) {
                try {
                    client.create(LOCK_PATH, new byte[0], ZooDefs.AclLists.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                    success = true;
                } catch (KeeperException e) {
                    if (e.code() == Code.NODEEXISTS) {
                        synchronized (lock) {
                            client.exists(LOCK_PATH, this);
                            lock.wait();
                        }
                    }
                }
            }
            LOG.info(Thread.currentThread().getName() + "获取锁成功");
        }


        public boolean tryLock() {
            try {
                client.create(LOCK_PATH, new byte[0], ZooDefs.AclLists.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                return true;
            } catch (Exception e) {
                return false;
            }
        }


        public void unlock() throws Exception {
            client.delete(LOCK_PATH, 0);
            LOG.info(Thread.currentThread().getName() + "释放锁成功");
        }


        @Override
        public void process(WatchedEvent event) {
            if ((event.getType() == EventType.NodeDeleted) && (LOCK_PATH.equals(event.getPath()))) {
                synchronized (lock) {
                    lock.notifyAll();
                }
            }
        }
    }

    /**
     * 竞争锁的线程,这里模拟加锁->业务操作->释放锁的流程
     */
    public static class FightThread extends Thread {

        public FightThread(String name) {
            super(name);
        }
        @Override
        public void run() {
            ZooKeeperLock lock;
            try {
              lock  = new ZooKeeperLock();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            System.out.println("开始竞争锁");
            while (true) {
                try {
                    lock.lock();
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    try {
                        lock.unlock();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        }
    }

    public static void main(String[] args) throws Exception{
        FightThread t1 = new FightThread("线程-1");
        t1.setDaemon(true);
        FightThread t2 = new FightThread("线程-2");
        t2.setDaemon(true);
        t1.start();
        t2.start();
        Thread.sleep(60000);
    }
}

2.Redis实现分布式锁

Redis因为服务端的串行化执行命令的特性，又提供了很多原子的get/set的命令，所以很适合用来实现分布式锁。网上的实现很多，但大部分都是很久之前的，下面提供一个使用spring-data-redis的实现的比较完整的。
redis中实现方式是：
加锁：通过set一个key并设置一个超时。加锁成功后，返回一个token，释放锁时需提供该token。
释放锁：首先获取当前key的值，如果key的值和持有的token相同，则删除key，否则不做任何事情。

代码实现:
加锁

public String tryLock(String name, long expire) {
        Assert.notNull(name, "Lock name must not be null");
        Assert.isTrue(expire>0, "expire must greater than 0");

        String token = UUID.randomUUID().toString(); //生成唯一的token
        //获取redis连接
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection conn = factory.getConnection();
        try{
            //原子操作，如果key不存在则set，并设置超时时间
            Boolean result = conn.set(name.getBytes(Charset.forName("UTF-8")), token.getBytes(Charset.forName("UTF-8")), 
                    Expiration.from(expire, TimeUnit.MILLISECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT);
            if(result!=null && result)
                return token;
        }finally {  //释放连接
            RedisConnectionUtils.releaseConnection(conn, factory);
        }
        return null;
    }

首先生成一个token，用来以后做锁的释放。
然后借助redis的SET key value PX milliseconds NX命令来设置锁，这条命令可以在一个原子操作中实现，如果key不存在则set，并且设置一个expire的时间。RedisConnection类提供了这个命令的接口。命令返回成功，则返回token，否则返回NULL，表明获取锁失败。
最后，因为我们自己获取的Connection，所以别忘记释放连接。

【注意】这里的使用UUID.randomUUID()方法生成的token并不能保证一定唯一。但是对于一般的系统是够用的，
主要是因为如果两次生成的token是一样的话，只对一个情况有影响，就是获取锁的线程1没有及时释放锁，
锁自动超时，然后线程2获取到锁，刚好线程2在获取锁时生成的token跟线程1是一样的。这个时候线程1来释放就会把不属于它的锁的释放掉。
这个概率是非常小的。如果你的系统对于唯一性非常敏感的话，需要换个token生成方式，保证唯一。

释放锁

public boolean unlock(String name, String token) {
        Assert.notNull(name, "Lock name must not be null");
        Assert.notNull(token, "Token must not be null");

        byte[][] keysAndArgs = new byte[2][];
        keysAndArgs[0] = name.getBytes(Charset.forName("UTF-8"));
        keysAndArgs[1] = token.getBytes(Charset.forName("UTF-8"));
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection conn = factory.getConnection();
        try {
            Long result = (Long)conn.scriptingCommands().eval(unlockScript.getBytes(Charset.forName("UTF-8")), ReturnType.INTEGER, 1, keysAndArgs);
            if(result!=null && result>0)
                return true;
        }finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }
        
        return false;
    }

释放锁需要三步，get->compare->del。由于redis中没有提供一个原子命令一次把这三件事做了,所以要借助lua脚本来实现，脚本如下(unlockScript变量)：

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

阻塞式加锁
我们系统中加锁一般都有需求，如果获取不到就阻塞一段时间。所以我们可以加一个这种接口，其实很简单，就是不断地循环调用tryLock，直到获取到或者超过时间。

public String lock(String name, long expire, long timeout) throws InterruptedException {
        //限制阻塞时间，根据自己的业务系统设置。如果尝试加锁的线程多的话最好不要设置的太大，要不然会有太多的线程在自旋，耗费CPU
        Assert.isTrue(timeout>0 && timeout<60000, "timeout must greater than 0 and less than 1 min");

        long startTime = System.currentTimeMillis();
        String token;
        do{
            token = tryLock(name, expire);
            if(token == null) { //加锁失败
                if((System.currentTimeMillis()-startTime) > (timeout-50)) 
                    break;  //超过阻塞时间则跳出
                Thread.sleep(50); //等待50ms再试，线程多的话这个值不建议设置的太小
            }
        }while(token==null);

        return token;
    }

【注】上面有两个时间值，一个是限制客户端最大阻塞时间，一个是每次自旋前的sleep时间，需要根据自己的业务情况调整。
锁的使用
锁的使用就注意一点，将unlock放到finally
springboot依赖，也可以用spring-data-redis加jedis或者lettuce

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-redis</artifactId>
         <version>2.0.5.RELEASE</version>
 </dependency>

耳听代码

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分布式锁实现方法

场景有两台client1和client2 并发的修改一个user表的数据,如果是数据库集群,client1 要修改user1的金额为20,client2要在20的基础上再加30,也就是要得到money=50的结果,这时如果没有分布式锁,可能出现的结果就是client1修改成功,数据库集群同步为20 ,之后client2修改成功集群整体修改为money=30分布式锁的要求提供阻塞和非阻塞...
复制链接

扫一扫