使用Java实现分布式锁

使用Java实现分布式锁

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在这篇文章中，我将详细介绍如何使用Java实现分布式锁，并结合实际代码示例，帮助大家更好地理解和应用分布式锁技术。

1. 什么是分布式锁

分布式锁是一种用于在分布式系统中控制对共享资源的访问的机制。在分布式环境中，多个进程可能需要同时访问某个共享资源，分布式锁可以确保在任何时刻只有一个进程能够访问该资源，从而避免数据竞争和不一致性问题。

2. 分布式锁的实现方式

分布式锁有多种实现方式，包括基于数据库的分布式锁、基于Redis的分布式锁、基于Zookeeper的分布式锁等。本文将重点介绍如何使用Redis实现分布式锁。

3. 使用Redis实现分布式锁

Redis是一种高性能的键值存储系统，非常适合用来实现分布式锁。我们可以利用Redis的原子操作来实现分布式锁。以下是一个基于Redis的分布式锁的实现示例：

3.1 引入依赖

首先，我们需要在项目中引入Jedis库来操作Redis。在pom.xml中添加以下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version>
</dependency>

3.2 分布式锁的实现

接下来，我们实现一个简单的分布式锁工具类：

package cn.juwatech.lock;

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {
    private Jedis jedis;
    private String lockKey;
    private int expireTime;

    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
    }

    public boolean lock() {
        long result = jedis.setnx(lockKey, String.valueOf(System.currentTimeMillis() + expireTime));
        if (result == 1) {
            jedis.expire(lockKey, expireTime);
            return true;
        } else {
            String currentValue = jedis.get(lockKey);
            if (currentValue != null && Long.parseLong(currentValue) < System.currentTimeMillis()) {
                String oldValue = jedis.getSet(lockKey, String.valueOf(System.currentTimeMillis() + expireTime));
                if (oldValue != null && oldValue.equals(currentValue)) {
                    jedis.expire(lockKey, expireTime);
                    return true;
                }
            }
        }
        return false;
    }

    public void unlock() {
        String currentValue = jedis.get(lockKey);
        if (currentValue != null && Long.parseLong(currentValue) > System.currentTimeMillis()) {
            jedis.del(lockKey);
        }
    }
}

3.3 使用示例

以下是一个使用Redis分布式锁的示例：

package cn.juwatech.lock;

import redis.clients.jedis.Jedis;

public class RedisDistributedLockExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        RedisDistributedLock lock = new RedisDistributedLock(jedis, "lockKey", 5000);

        if (lock.lock()) {
            try {
                // 执行业务逻辑
                System.out.println("获得锁，执行任务");
            } finally {
                lock.unlock();
                System.out.println("释放锁");
            }
        } else {
            System.out.println("未获得锁，任务跳过");
        }
    }
}

4. 基于Zookeeper的分布式锁

Zookeeper也是一种常用的分布式协调服务，可以用来实现分布式锁。Zookeeper通过创建临时节点来实现分布式锁。

4.1 引入依赖

在pom.xml中添加Zookeeper的依赖：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.7.0</version>
</dependency>

4.2 分布式锁的实现

接下来，我们实现一个基于Zookeeper的分布式锁工具类：

package cn.juwatech.lock;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;

public class ZookeeperDistributedLock {
    private ZooKeeper zooKeeper;
    private String lockRoot = "/locks";
    private String lockName;
    private String lockPath;

    public ZookeeperDistributedLock(ZooKeeper zooKeeper, String lockName) {
        this.zooKeeper = zooKeeper;
        this.lockName = lockName;
    }

    public boolean lock() throws Exception {
        String path = zooKeeper.create(lockRoot + "/" + lockName + "_", new byte[0],
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        this.lockPath = path;

        List<String> children = zooKeeper.getChildren(lockRoot, false);
        Collections.sort(children);

        if (path.equals(lockRoot + "/" + children.get(0))) {
            return true;
        }

        String prevNode = null;
        for (String node : children) {
            if (path.equals(lockRoot + "/" + node)) {
                break;
            }
            prevNode = node;
        }

        if (prevNode != null) {
            Stat stat = zooKeeper.exists(lockRoot + "/" + prevNode, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    synchronized (this) {
                        notifyAll();
                    }
                }
            });

            if (stat != null) {
                synchronized (this) {
                    wait();
                }
            }
        }

        return true;
    }

    public void unlock() throws Exception {
        zooKeeper.delete(this.lockPath, -1);
    }
}

4.3 使用示例

以下是一个使用Zookeeper分布式锁的示例：

package cn.juwatech.lock;

import org.apache.zookeeper.ZooKeeper;

public class ZookeeperDistributedLockExample {
    public static void main(String[] args) throws Exception {
        ZooKeeper zooKeeper = new ZooKeeper("localhost:2181", 3000, null);
        ZookeeperDistributedLock lock = new ZookeeperDistributedLock(zooKeeper, "testLock");

        if (lock.lock()) {
            try {
                // 执行业务逻辑
                System.out.println("获得锁，执行任务");
            } finally {
                lock.unlock();
                System.out.println("释放锁");
            }
        } else {
            System.out.println("未获得锁，任务跳过");
        }
    }
}

总结

通过以上内容，我们介绍了如何使用Java实现分布式锁，重点演示了基于Redis和Zookeeper的分布式锁的实现和使用方法。著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！