From 711586151e68f798a676ce31294d0c5e4c3a8489 Mon Sep 17 00:00:00 2001 From: Nikita Koksharov Date: Thu, 6 Dec 2018 14:17:53 +0300 Subject: [PATCH] Feature - getReadWriteLock, getCountDownLatch, getSemaphore, getPermitExpirableSemaphore, getFairLock methods added to RSet and RSetCache objects #1786 --- .../main/java/org/redisson/RedissonSet.java | 40 ++++++++++++++++-- .../java/org/redisson/RedissonSetCache.java | 40 ++++++++++++++++-- .../redisson/RedissonSetMultimapValues.java | 32 +++++++++++++- .../src/main/java/org/redisson/api/RSet.java | 42 ++++++++++++++++++- .../main/java/org/redisson/api/RSetCache.java | 42 ++++++++++++++++++- .../transaction/RedissonTransactionalSet.java | 35 ++++++++++++++++ .../transaction/TransactionalSet.java | 2 +- .../transaction/TransactionalSetCache.java | 2 +- .../operation/set/SetOperation.java | 4 +- 9 files changed, 226 insertions(+), 13 deletions(-) diff --git a/redisson/src/main/java/org/redisson/RedissonSet.java b/redisson/src/main/java/org/redisson/RedissonSet.java index a7318db63..8b266165a 100644 --- a/redisson/src/main/java/org/redisson/RedissonSet.java +++ b/redisson/src/main/java/org/redisson/RedissonSet.java @@ -23,8 +23,12 @@ import java.util.Iterator; import java.util.List; import java.util.Set; +import org.redisson.api.RCountDownLatch; import org.redisson.api.RFuture; import org.redisson.api.RLock; +import org.redisson.api.RPermitExpirableSemaphore; +import org.redisson.api.RReadWriteLock; +import org.redisson.api.RSemaphore; import org.redisson.api.RSet; import org.redisson.api.RedissonClient; import org.redisson.api.SortOrder; @@ -602,20 +606,50 @@ public class RedissonSet extends RedissonExpirable implements RSet, ScanIt return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); } - public String getLockName(Object value) { + public String getLockName(Object value, String suffix) { ByteBuf state = encode(value); try { - return suffixName(getName(value), Hash.hash128toBase64(state) + ":lock"); + return suffixName(getName(value), Hash.hash128toBase64(state) + ":" + suffix); } finally { state.release(); } } + + @Override + public RPermitExpirableSemaphore getPermitExpirableSemaphore(V value) { + String lockName = getLockName(value, "permitexpirablesemaphore"); + return new RedissonPermitExpirableSemaphore(commandExecutor, lockName, ((Redisson)redisson).getSemaphorePubSub()); + } + + @Override + public RSemaphore getSemaphore(V value) { + String lockName = getLockName(value, "semaphore"); + return new RedissonSemaphore(commandExecutor, lockName, ((Redisson)redisson).getSemaphorePubSub()); + } + + @Override + public RCountDownLatch getCountDownLatch(V value) { + String lockName = getLockName(value, "countdownlatch"); + return new RedissonCountDownLatch(commandExecutor, lockName); + } + + @Override + public RLock getFairLock(V value) { + String lockName = getLockName(value, "fairlock"); + return new RedissonFairLock(commandExecutor, lockName); + } @Override public RLock getLock(V value) { - String lockName = getLockName(value); + String lockName = getLockName(value, "lock"); return new RedissonLock(commandExecutor, lockName); } + + @Override + public RReadWriteLock getReadWriteLock(V value) { + String lockName = getLockName(value, "rw_lock"); + return new RedissonReadWriteLock(commandExecutor, lockName); + } @Override public RFuture> scanIteratorAsync(String name, RedisClient client, long startPos, diff --git a/redisson/src/main/java/org/redisson/RedissonSetCache.java b/redisson/src/main/java/org/redisson/RedissonSetCache.java index 76b77dc27..a03afe67d 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetCache.java +++ b/redisson/src/main/java/org/redisson/RedissonSetCache.java @@ -24,8 +24,12 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.redisson.api.RCountDownLatch; import org.redisson.api.RFuture; import org.redisson.api.RLock; +import org.redisson.api.RPermitExpirableSemaphore; +import org.redisson.api.RReadWriteLock; +import org.redisson.api.RSemaphore; import org.redisson.api.RSetCache; import org.redisson.api.RedissonClient; import org.redisson.api.mapreduce.RCollectionMapReduce; @@ -366,20 +370,50 @@ public class RedissonSetCache extends RedissonExpirable implements RSetCache< delete(); } - public String getLockName(Object value) { + public String getLockName(Object value, String suffix) { ByteBuf state = encode(value); try { - return suffixName(getName(value), Hash.hash128toBase64(state) + ":lock"); + return suffixName(getName(value), Hash.hash128toBase64(state) + ":" + suffix); } finally { state.release(); } } + + @Override + public RPermitExpirableSemaphore getPermitExpirableSemaphore(V value) { + String lockName = getLockName(value, "permitexpirablesemaphore"); + return new RedissonPermitExpirableSemaphore(commandExecutor, lockName, ((Redisson)redisson).getSemaphorePubSub()); + } + + @Override + public RSemaphore getSemaphore(V value) { + String lockName = getLockName(value, "semaphore"); + return new RedissonSemaphore(commandExecutor, lockName, ((Redisson)redisson).getSemaphorePubSub()); + } + + @Override + public RCountDownLatch getCountDownLatch(V value) { + String lockName = getLockName(value, "countdownlatch"); + return new RedissonCountDownLatch(commandExecutor, lockName); + } + + @Override + public RLock getFairLock(V value) { + String lockName = getLockName(value, "fairlock"); + return new RedissonFairLock(commandExecutor, lockName); + } @Override public RLock getLock(V value) { - String lockName = getLockName(value); + String lockName = getLockName(value, "lock"); return new RedissonLock(commandExecutor, lockName); } + + @Override + public RReadWriteLock getReadWriteLock(V value) { + String lockName = getLockName(value, "rw_lock"); + return new RedissonReadWriteLock(commandExecutor, lockName); + } @Override public void destroy() { diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java index 5ab429cc3..d2af8aad5 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java @@ -23,8 +23,12 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.redisson.api.RCountDownLatch; import org.redisson.api.RFuture; import org.redisson.api.RLock; +import org.redisson.api.RPermitExpirableSemaphore; +import org.redisson.api.RReadWriteLock; +import org.redisson.api.RSemaphore; import org.redisson.api.RSet; import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; @@ -49,7 +53,8 @@ import org.redisson.command.CommandAsyncExecutor; */ public class RedissonSetMultimapValues extends RedissonExpirable implements RSet { - private static final RedisCommand> EVAL_SSCAN = new RedisCommand>("EVAL", new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.MAP_VALUE); + private static final RedisCommand> EVAL_SSCAN = new RedisCommand>("EVAL", + new ListMultiDecoder(new LongMultiDecoder(), new ObjectListReplayDecoder(), new ListScanResultReplayDecoder()), ValueType.MAP_VALUE); private final RSet set; private final Object key; @@ -468,6 +473,31 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R Arrays.asList(timeoutSetName, getName()), args.toArray()); } + @Override + public RCountDownLatch getCountDownLatch(V value) { + return set.getCountDownLatch(value); + } + + @Override + public RPermitExpirableSemaphore getPermitExpirableSemaphore(V value) { + return set.getPermitExpirableSemaphore(value); + } + + @Override + public RSemaphore getSemaphore(V value) { + return set.getSemaphore(value); + } + + @Override + public RLock getFairLock(V value) { + return set.getFairLock(value); + } + + @Override + public RReadWriteLock getReadWriteLock(V value) { + return set.getReadWriteLock(value); + } + @Override public RLock getLock(V value) { return set.getLock(value); diff --git a/redisson/src/main/java/org/redisson/api/RSet.java b/redisson/src/main/java/org/redisson/api/RSet.java index 62debf2c9..062820b48 100644 --- a/redisson/src/main/java/org/redisson/api/RSet.java +++ b/redisson/src/main/java/org/redisson/api/RSet.java @@ -29,11 +29,51 @@ import org.redisson.api.mapreduce.RCollectionMapReduce; */ public interface RSet extends Set, RExpirable, RSetAsync, RSortable> { + /** + * Returns RCountDownLatch instance associated with value + * + * @param value - set value + * @return RCountDownLatch object + */ + RCountDownLatch getCountDownLatch(V value); + + /** + * Returns RPermitExpirableSemaphore instance associated with value + * + * @param value - set value + * @return RPermitExpirableSemaphore object + */ + RPermitExpirableSemaphore getPermitExpirableSemaphore(V value); + + /** + * Returns RSemaphore instance associated with value + * + * @param value - set value + * @return RSemaphore object + */ + RSemaphore getSemaphore(V value); + + /** + * Returns RReadWriteLock instance associated with value + * + * @param value - set value + * @return RLock object + */ + RLock getFairLock(V value); + + /** + * Returns RReadWriteLock instance associated with value + * + * @param value - set value + * @return RReadWriteLock object + */ + RReadWriteLock getReadWriteLock(V value); + /** * Returns lock instance associated with value * * @param value - set value - * @return lock + * @return RLock object */ RLock getLock(V value); diff --git a/redisson/src/main/java/org/redisson/api/RSetCache.java b/redisson/src/main/java/org/redisson/api/RSetCache.java index ae78e7d07..0104e07db 100644 --- a/redisson/src/main/java/org/redisson/api/RSetCache.java +++ b/redisson/src/main/java/org/redisson/api/RSetCache.java @@ -40,11 +40,51 @@ import org.redisson.api.mapreduce.RCollectionMapReduce; */ public interface RSetCache extends Set, RExpirable, RSetCacheAsync, RDestroyable { + /** + * Returns RCountDownLatch instance associated with value + * + * @param value - set value + * @return RCountDownLatch object + */ + RCountDownLatch getCountDownLatch(V value); + + /** + * Returns RPermitExpirableSemaphore instance associated with value + * + * @param value - set value + * @return RPermitExpirableSemaphore object + */ + RPermitExpirableSemaphore getPermitExpirableSemaphore(V value); + + /** + * Returns RSemaphore instance associated with value + * + * @param value - set value + * @return RSemaphore object + */ + RSemaphore getSemaphore(V value); + + /** + * Returns RReadWriteLock instance associated with value + * + * @param value - set value + * @return RLock object + */ + RLock getFairLock(V value); + + /** + * Returns RReadWriteLock instance associated with value + * + * @param value - set value + * @return RReadWriteLock object + */ + RReadWriteLock getReadWriteLock(V value); + /** * Returns lock instance associated with value * * @param value - set value - * @return lock + * @return RLock object */ RLock getLock(V value); diff --git a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java index 25c200e68..9c45acb40 100644 --- a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java @@ -23,7 +23,12 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import org.redisson.RedissonSet; +import org.redisson.api.RCountDownLatch; import org.redisson.api.RFuture; +import org.redisson.api.RLock; +import org.redisson.api.RPermitExpirableSemaphore; +import org.redisson.api.RReadWriteLock; +import org.redisson.api.RSemaphore; import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; @@ -99,6 +104,36 @@ public class RedissonTransactionalSet extends RedissonSet { checkState(); return transactionalSet.scanIterator(name, client, startPos, pattern, count); } + + @Override + public RLock getFairLock(V value) { + throw new UnsupportedOperationException("getFairLock method is not supported in transaction"); + } + + @Override + public RCountDownLatch getCountDownLatch(V value) { + throw new UnsupportedOperationException("getCountDownLatch method is not supported in transaction"); + } + + @Override + public RPermitExpirableSemaphore getPermitExpirableSemaphore(V value) { + throw new UnsupportedOperationException("getPermitExpirableSemaphore method is not supported in transaction"); + } + + @Override + public RSemaphore getSemaphore(V value) { + throw new UnsupportedOperationException("getSemaphore method is not supported in transaction"); + } + + @Override + public RLock getLock(V value) { + throw new UnsupportedOperationException("getLock method is not supported in transaction"); + } + + @Override + public RReadWriteLock getReadWriteLock(V value) { + throw new UnsupportedOperationException("getReadWriteLock method is not supported in transaction"); + } @Override public RFuture containsAsync(Object o) { diff --git a/redisson/src/main/java/org/redisson/transaction/TransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/TransactionalSet.java index 47920c413..1d03bc1de 100644 --- a/redisson/src/main/java/org/redisson/transaction/TransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/TransactionalSet.java @@ -77,7 +77,7 @@ public class TransactionalSet extends BaseTransactionalSet { @Override protected RLock getLock(RCollectionAsync set, V value) { - String lockName = ((RedissonSet)set).getLockName(value); + String lockName = ((RedissonSet)set).getLockName(value, "lock"); return new RedissonTransactionalLock(commandExecutor, lockName, transactionId); } diff --git a/redisson/src/main/java/org/redisson/transaction/TransactionalSetCache.java b/redisson/src/main/java/org/redisson/transaction/TransactionalSetCache.java index 483b359b4..a50b89f81 100644 --- a/redisson/src/main/java/org/redisson/transaction/TransactionalSetCache.java +++ b/redisson/src/main/java/org/redisson/transaction/TransactionalSetCache.java @@ -82,7 +82,7 @@ public class TransactionalSetCache extends BaseTransactionalSet { @Override protected RLock getLock(RCollectionAsync set, V value) { - String lockName = ((RedissonSetCache)set).getLockName(value); + String lockName = ((RedissonSetCache)set).getLockName(value, "lock"); return new RedissonTransactionalLock(commandExecutor, lockName, transactionId); } diff --git a/redisson/src/main/java/org/redisson/transaction/operation/set/SetOperation.java b/redisson/src/main/java/org/redisson/transaction/operation/set/SetOperation.java index edfffffdf..e2038871f 100644 --- a/redisson/src/main/java/org/redisson/transaction/operation/set/SetOperation.java +++ b/redisson/src/main/java/org/redisson/transaction/operation/set/SetOperation.java @@ -40,12 +40,12 @@ public abstract class SetOperation extends TransactionalOperation { } protected RLock getLock(RSetCache setCache, CommandAsyncExecutor commandExecutor, Object value) { - String lockName = ((RedissonSetCache)setCache).getLockName(value); + String lockName = ((RedissonSetCache)setCache).getLockName(value, "lock"); return new RedissonTransactionalLock(commandExecutor, lockName, transactionId); } protected RLock getLock(RSet setCache, CommandAsyncExecutor commandExecutor, Object value) { - String lockName = ((RedissonSet)setCache).getLockName(value); + String lockName = ((RedissonSet)setCache).getLockName(value, "lock"); return new RedissonTransactionalLock(commandExecutor, lockName, transactionId); }