分布式锁和同步器

TOC

Lock

Redisson 分布式可重入锁，实现了 java.util.concurrent.locks.Lock 接口并支持 TTL。

  1. RLock lock = redisson.getLock("anyLock");
  2. // Most familiar locking method
  3. lock.lock();
  5. // Lock time-to-live support
  6. // releases lock automatically after 10 seconds
  7. // if unlock method not invoked
  8. lock.lock(10, TimeUnit.SECONDS);
  10. // Wait for 100 seconds and automatically unlock it after 10 seconds
  11. boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
  12. ...
  13. lock.unlock();

Redisson 也支持 Lock 对象的异步方法：

  1. RLock lock = redisson.getLock("anyLock");
  2. lock.lockAsync();
  3. lock.lockAsync(10, TimeUnit.SECONDS);
  4. Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

Fair Lock

Redisson 分布式可重入公平锁，实现了 java.util.concurrent.locks.Lock 接口并支持 TTL，
并且保证 Redisson 客户端线程将以其请求的顺序获得锁。
它和简单的 Lock 对象有相同的接口。

  1. RLock fairLock = redisson.getFairLock("anyLock");
  2. // Most familiar locking method
  3. fairLock.lock();
  5. // Lock time-to-live support
  6. // releases lock automatically after 10 seconds
  7. // if unlock method not invoked
  8. fairLock.lock(10, TimeUnit.SECONDS);
  10. // Wait for 100 seconds and automatically unlock it after 10 seconds
  11. boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
  12. ...
  13. fairLock.unlock();

Redisson 也支持公平锁对象的异步方法：

  1. RLock fairLock = redisson.getFairLock("anyLock");
  2. fairLock.lockAsync();
  3. fairLock.lockAsync(10, TimeUnit.SECONDS);
  4. Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);

MultiLock

RedissonMultiLock 对象可用于实现 Redlock 锁算法。
它将多个 RLock 对象划为一组并且将它们当作一个锁来处理。
每个 RLock 对象可以属于不同的 Redisson 实例。

  1. RLock lock1 = redissonInstance1.getLock("lock1");
  2. RLock lock2 = redissonInstance2.getLock("lock2");
  3. RLock lock3 = redissonInstance3.getLock("lock3");
  5. RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
  6. // locks: lock1 lock2 lock3
  7. lock.lock();
  8. ...
  9. lock.unlock();

ReadWriteLock

Redisson 分布式可重入 ReadWriteLock 对象，实现了 java.util.concurrent.locks.ReadWriteLock 接口并支持 TTL。
可以同时存在多个 ReadLock 拥有者，但仅允许有一个 WriteLock

  1. RReadWriteLock rwlock = redisson.getLock("anyRWLock");
  2. // Most familiar locking method
  3. rwlock.readLock().lock();
  4. // or
  5. rwlock.writeLock().lock();
  7. // Lock time-to-live support
  8. // releases lock automatically after 10 seconds
  9. // if unlock method not invoked
  10. rwlock.readLock().lock(10, TimeUnit.SECONDS);
  11. // or
  12. rwlock.writeLock().lock(10, TimeUnit.SECONDS);
  14. // Wait for 100 seconds and automatically unlock it after 10 seconds
  15. boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
  16. // or
  17. boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
  18. ...
  19. lock.unlock();

Semaphore

Redisson 分布式 Semaphore 对象，类似于 java.util.concurrent.Semaphore 对象。

  1. RSemaphore semaphore = redisson.getSemaphore("semaphore");
  2. semaphore.acquire();
  3. //or
  4. semaphore.acquireAsync();
  5. semaphore.acquire(23);
  6. semaphore.tryAcquire();
  7. //or
  8. semaphore.tryAcquireAsync();
  9. semaphore.tryAcquire(23, TimeUnit.SECONDS);
  10. //or
  11. semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
  12. semaphore.release(10);
  13. semaphore.release();
  14. //or
  15. semaphore.releaseAsync();

CountDownLatch

Redisson 分布式 CountDownLatch 对象，结构类似于 java.util.concurrent.CountDownLatch 对象。

  1. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
  2. latch.trySetCount(1);
  3. latch.await();
  5. // in other thread or other JVM
  6. RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
  7. latch.countDown();