java分布式锁代码

在 Java 中，可以使用 java.util.concurrent 包中的 ReentrantLock 类来实现分布式锁。

下面是一个示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class DistributedLock {
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 获取锁
        lock.lock();
        try {
            // 这里是临界区代码，在这里进行读写操作
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}

在上面的代码中，首先使用 lock() 方法获取锁，然后在 try-finally 块中执行临界区代码。最后使用 unlock() 方法释放锁。

注意：在使用 ReentrantLock 类时，一定要记得在 finally 块中释放锁，否则可能会造成死锁。

相关问题

java 分布式锁代码

以下是一个简单的基于 Redis 实现的 Java 分布式锁代码示例：

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {
    private static final String LOCK_KEY_PREFIX = "lock:";
    private Jedis jedis;

    public RedisDistributedLock(String host, int port) {
        jedis = new Jedis(host, port);
    }

    public boolean acquireLock(String lockName, long expireTime) {
        String lockKey = LOCK_KEY_PREFIX + lockName;
        long currentTime = System.currentTimeMillis();
        long lockTimeout = currentTime + expireTime;

        String result = jedis.set(lockKey, String.valueOf(lockTimeout), "NX", "PX", expireTime);
        return "OK".equals(result);
    }

    public void releaseLock(String lockName) {
        String lockKey = LOCK_KEY_PREFIX + lockName;
        jedis.del(lockKey);
    }
}

使用示例：

RedisDistributedLock lock = new RedisDistributedLock("localhost", 6379);
if (lock.acquireLock("myLock", 1000)) {
    try {
        // 执行需要加锁的逻辑
    } finally {
        lock.releaseLock("myLock");
    }
} else {
    // 获取锁失败
}

这个示例中使用了 Redis 的 SET command 和 DEL command 实现了分布式锁。在 acquireLock 方法中，我们将 lockKey 设置为一个具有过期时间的值，并使用 NX（不存在则设置）选项来保证这个 key 只会被设置一次。如果设置成功，就说明获取到了锁；否则，就说明锁已经被其他进程占据了。在执行需要加锁的逻辑之前，我们需要检查是否成功获取到了锁；在逻辑执行完毕后，我们需要调用 releaseLock 方法来删除这个 key，释放锁。

java实现分布式锁代码

以下是基于Redis实现分布式锁的Java代码示例：

import redis.clients.jedis.Jedis;

public class RedisLock {
    private static final String LOCK_KEY = "redis_lock"; // 锁的键
    private static final int LOCK_EXPIRE = 300; // 锁的过期时间，单位秒
    private static final int ACQUIRE_TIMEOUT = 1000; // 获取锁的超时时间，单位毫秒
    private Jedis jedis;

    public RedisLock() {
        jedis = new Jedis("localhost", 6379);
    }

    public boolean acquireLock() {
        long end = System.currentTimeMillis() + ACQUIRE_TIMEOUT;
        String identifier = String.valueOf(Thread.currentThread().getId());
        while (System.currentTimeMillis() < end) {
            if (jedis.setnx(LOCK_KEY, identifier) == 1) {
                jedis.expire(LOCK_KEY, LOCK_EXPIRE);
                return true;
            }
            if (jedis.ttl(LOCK_KEY) == -1) {
                jedis.expire(LOCK_KEY, LOCK_EXPIRE);
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return false;
    }

    public void releaseLock() {
        if (jedis.del(LOCK_KEY) == 0) {
            // 解锁失败
        }
    }
}

以下是基于Zookeeper实现分布式锁的Java代码示例：

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class ZookeeperLock {
    private static final String LOCK_PATH = "/zookeeper_lock"; // 锁的路径
    private static final int SESSION_TIMEOUT = 3000; // 会话超时时间，单位毫秒
    private ZooKeeper zooKeeper;
    private CountDownLatch connectedSignal = new CountDownLatch(1);
    private String identifier;

    public ZookeeperLock() {
        try {
            zooKeeper = new ZooKeeper("localhost:2181", SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getState() == Event.KeeperState.SyncConnected) {
                        connectedSignal.countDown();
                    }
                }
            });
            connectedSignal.await();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    public boolean acquireLock() {
        try {
            identifier = String.valueOf(Thread.currentThread().getId());
            String lockPath = zooKeeper.create(LOCK_PATH + "/lock_", identifier.getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            List<String> children = zooKeeper.getChildren(LOCK_PATH, false);
            Collections.sort(children);
            if (lockPath.equals(LOCK_PATH + "/" + children.get(0))) {
                return true;
            } else {
                String prevNodePath = LOCK_PATH + "/" + children.get(Collections.binarySearch(children, lockPath.substring(LOCK_PATH.length() + 1)) - 1);
                Stat stat = zooKeeper.exists(prevNodePath, new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        if (event.getType() == Event.EventType.NodeDeleted) {
                            synchronized (this) {
                                notifyAll();
                            }
                        }
                    }
                });
                if (stat == null) {
                    return acquireLock();
                } else {
                    synchronized (stat) {
                        stat.wait();
                    }
                    return acquireLock();
                }
            }
        } catch (KeeperException | InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    public void releaseLock() {
        try {
            zooKeeper.delete(LOCK_PATH + "/" + identifier, -1);
        } catch (InterruptedException | KeeperException e) {
            e.printStackTrace();
        }
    }
}

注意：以上代码仅供参考，实际使用时需要根据具体需求进行调整和完善。