RedUtils

Distributed Lock Implementation With Redis

Note

For reading the idea and the algorithm behind this, please visit https://dzone.com/articles/distributed-lock-implementation-with-redis

Introduction

RedUtils is a distributed lock and using Redis for storing and expiring locks. It has the following features:

Leased-Based Lock: If any clients crash or restarted abnormally, eventually lock will be free.
Safe: Provided that fsync=always on every Redis instance we have safety even if Redis become unavailable after getting lock.
Auto-Refreshing Lock: A lock that is acquired by the client can be held as long as the client is alive, and the connection is OK.

Getting Started

Requirements

Install Redis or use the following command if you have Docker installed

docker run --name some-redis  -e ALLOW_EMPTY_PASSWORD=yes -p 6379:6379 --rm -it redis

Add the following dependency (Java 8 is required)

<dependency>
    <groupId>com.github.siahsang</groupId>
    <artifactId>red-utils</artifactId>
    <version>1.0.4</version>
</dependency>

How to use it?

Getting the lock with the default configuration. Wait for getting the lock if it is acquired by another thread.

RedUtilsLock redUtilsLock = new RedUtilsLockImpl();
redUtilsLock.acquire("lock1", () -> {
    // some operation
});

Try to acquire the lock and return true after executing the operation, otherwise, return false immediately.

RedUtilsLock redUtilsLock = new RedUtilsLockImpl();
boolean getLockSuccessfully = redUtilsLock.tryAcquire("lock1", () -> {
    // some operation
});

You can also provide configuration when initializing RedUtilsLock

RedUtilsConfig redUtilsConfig = new RedUtilsConfig.RedUtilsConfigBuilder()
            .hostAddress("127.0.0.1")
            .port("6379")
            .replicaCount(3)
            .leaseTimeMillis(40_000)
            .build();

RedUtilsLock redUtilsLock = new RedUtilsLockImpl(redUtilsConfig);

To see more examples please see the tests

Running the tests

For running the tests, you should install Docker(test cases use testcontainer for running Redis). After that you can run all tests with:

mvn clean test

Caveats

There are some caveats that you should be aware of:

I assume clocks are synchronized between different nodes.
I assume there aren't any long thread pause or process pause after getting lock but before using it.
To achieve strong consistency you should enable the option fsync=always on every Redis instance.
In current implementation, locks is not fair; for example, a client may wait a long time to get the lock and at the same time another client get the lock immediately.

Dependencies

Jedis
Slf4j

siahsang/red-utils