SoFunction
Updated on 2025-03-06

Selection and performance comparison of four common Java distributed locks

1. Distributed lock based on database

Implementation principle:A database-based distributed lock is implemented using the database's transaction mechanism and unique index. When you need to acquire the lock, try to insert a record with a unique index in the database. If the insertion is successful, it means that the lock has been acquired; otherwise, it means that the lock has been occupied by other nodes.

Implementation example:Suppose there is a tabledistributed_lock, which contains a unique index fieldlock_key. The Java code example is as follows:

public class DatabaseDistributedLock {
    private static final String LOCK_KEY = "my_lock_key";
    private DataSource dataSource;

    public boolean acquireLock() {
        try (Connection connection = ()) {
            (false);
            try (PreparedStatement statement = (
                    "INSERT INTO distributed_lock (lock_key) VALUES (?)")) {
                (1, LOCK_KEY);
                ();
                ();
                return true;
            } catch (SQLException e) {
                ();
                return false;
            }
        } catch (SQLException e) {
            // Handle exceptions        }
        return false;
    }

    public void releaseLock() {
        try (Connection connection = ()) {
            (false);
            try (PreparedStatement statement = (
                    "DELETE FROM distributed_lock WHERE lock_key = ?")) {
                (1, LOCK_KEY);
                ();
                ();
            } catch (SQLException e) {
                ();
                // Handle exceptions            }
        } catch (SQLException e) {
            // Handle exceptions        }
    }
}

Application scenarios:Database-based distributed locks are suitable for scenarios where data consistency is not high and the locks have a coarse granularity. For example, when controlling a task can only be executed by one node in a distributed system, a database-based distributed lock can be used.

advantage:

  • Simple implementation, easy to understand and maintain;
  • The transaction mechanism of the database can be used to ensure the reliability of the lock.

shortcoming:

  • Low efficiency. Frequent operation of the database will put a lot of pressure on the database and will easily become a performance bottleneck;
  • There is a deadlock problem. When the node that acquires the lock does not release the lock for some reason, it will cause other nodes to fail to acquire the lock and fall into a deadlock.

2. Cache-based distributed lock

Implementation principle:Cache-based distributed locks are implemented using the atomic operation and expiration time characteristics of the cache system. When you need to acquire the lock, try to set a lock flag with an expiration time in the cache. If the setting is successful, it means that the lock has been acquired; otherwise, it means that the lock has been occupied by other nodes.

Implementation example:Assuming that Redis is used as the cache system, Redis can be usedSETNXCommands (set key-value pairs atomically, and set successfully only when the key does not exist) to implement distributed locks. The Java code example is as follows:

public class CacheDistributedLock {
    private static final String LOCK_KEY = "my_lock_key";
    private static final int LOCK_EXPIRE_TIME = 5000; // The expiration time of the lock, in milliseconds    private Jedis jedis;
    public boolean acquireLock() {
        String result = (LOCK_KEY, "true", "NX", "PX", LOCK_EXPIRE_TIME);
        return "OK".equals(result);
    }
    public void releaseLock() {
        (LOCK_KEY);
    }
}

Application scenarios:Cache-based distributed locks are suitable for scenarios where data consistency is high and locks are finer. For example, in a flash sale system, a cache-based distributed lock can be used to control the rush purchase operation of the product.

advantage:

  • Simple implementation and high performance. Cache systems usually have efficient read and write performance, and perform better for a simple lock mechanism;
  • Support blocking and waiting. The atomic operation and expiration time characteristics of the cache system can be used to realize the blocking and waiting function of locks.

shortcoming:

  • A cache failure can cause the lock to fail. When the cache system fails or the cache node fails, the lock will not be released normally or be mistakenly considered by other nodes to have been occupied, resulting in the distributed lock failure;
  • There is a deadlock problem. When the node that acquires the lock does not release the lock for some reason, it will cause other nodes to fail to acquire the lock and fall into a deadlock.

3. Distributed lock based on ZooKeeper

Implementation principle:Distributed locks based on ZooKeeper are implemented using ZooKeeper's node monitoring mechanism and ordered node characteristics. When a lock is needed, each node creates a persistent sequential node on ZooKeeper and acquires the node with the smallest sequence number among all child nodes as the lock. When the lock needs to be released, the node deletes the corresponding persistent sequential node.

Implementation example:Assuming that Curator is used as ZooKeeper's client library, you can useInterProcessMutexclass to implement distributed locks. The Java code example is as follows:

public class ZooKeeperDistributedLock {
    private static final String LOCK_PATH = "/my_lock_path";
    private CuratorFramework client;
    private InterProcessMutex lock;

    public boolean acquireLock() {
        try {
            ();
            return true;
        } catch (Exception e) {
            // Handle exceptions        }
        return false;
    }

    public void releaseLock() {
        try {
            ();
        } catch (Exception e) {
            // Handle exceptions        }
    }
}

Application scenarios:Distributed locks based on ZooKeeper are suitable for scenarios where data consistency is high and locks are finer. For example, when exclusive access to a resource in a distributed system, a distributed lock based on ZooKeeper can be used.

advantage:

  • High availability and reliability. ZooKeeper, as a distributed coordination service, provides highly available and reliable services;
  • It has sequence. ZooKeeper's persistent sequential nodes can ensure the order of nodes and avoid the occurrence of deadlock problems;
  • Support blocking and waiting. ZooKeeper's node monitoring mechanism can be used to realize the blocking and waiting function of locks.

shortcoming:

  • The implementation is relatively complex. Compared with database and cache methods, the implementation method based on ZooKeeper needs to involve ZooKeeper's API and node monitoring mechanism, and the implementation and maintenance are more complex;
  • Relatively low performance. Compared with database and cache methods, the implementation method based on ZooKeeper has lower performance because it involves the overhead of network communication and node monitoring.

4. Distributed lock based on Redis

Implementation principle:Redis-based distributed locks are implemented using Redis' atomic operation and expiration time characteristics. When you need to acquire the lock, try to set a lock flag with an expiration time in Redis. If the setting is successful, it means that the lock has been acquired; otherwise, it means that the lock has been occupied by other nodes.

Implementation example:The Java code example is as follows:

public class RedisDistributedLock {
    private static final String LOCK_KEY = "my_lock_key";
    private static final String LOCK_VALUE = "true";
    private static final long LOCK_EXPIRE_TIME = 5000; // The expiration time of the lock, in milliseconds    private Jedis jedis;

    public boolean acquireLock() {
        String result = (LOCK_KEY, LOCK_VALUE, "NX", "PX", LOCK_EXPIRE_TIME);
        return "OK".equals(result);
    }

    public void releaseLock() {
        if (LOCK_VALUE.equals((LOCK_KEY))) {
            (LOCK_KEY);
        }
    }
}

Application scenarios:Redis-based distributed locks are suitable for scenarios where data consistency is high and locks have fine granularity. For example, when exclusive access to a resource in a distributed system, a distributed lock based on Redis can be used.

advantage:

  • Simple implementation and high performance. As an in-memory database, Redis has efficient read and write performance, and performs better for a simple lock mechanism;
  • Support blocking and waiting. The atomic operation and expiration time characteristics of Redis can be used to realize the blocking and waiting function of locks;
  • High availability and reliability. Redis supports master-slave replication and cluster deployment, with high availability and reliability.

shortcoming:

  • Expiration time management of locks. It is necessary to ensure that the expiration time of the lock is long enough to avoid the problem of data inconsistency caused by the node's expiration of the lock when executing business logic;
  • Lock error release problem. When a node acquires a lock, it fails to release the lock correctly due to an exception or other reasons, which will cause other nodes to fail to acquire the lock and cause data access exceptions.

The above is a detailed analysis of several common distributed lock implementation principles, implementation examples, application scenarios, and advantages and disadvantages. In practical applications, choosing a suitable distributed lock implementation method requires comprehensive consideration of factors such as the characteristics, performance requirements and reliability requirements of the system.

This is the article about the selection and performance comparison of four common Java distributed locks. For more related Java distributed lock content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!