From 895994a357d19cb2030ae5c1028b1db59d30fab8 Mon Sep 17 00:00:00 2001 From: Nikita Date: Mon, 19 Jun 2017 16:20:11 +0300 Subject: [PATCH] methods with threadId parameter added to RLockAsync interface --- .../main/java/org/redisson/RedissonLock.java | 14 ++- .../java/org/redisson/api/RLockAsync.java | 12 ++- .../java/org/redisson/api/map/MapWriter.java | 38 +++++++ .../test/java/org/redisson/BaseMapTest.java | 101 ++++++++++++++++++ 4 files changed, 163 insertions(+), 2 deletions(-) create mode 100644 redisson/src/main/java/org/redisson/api/map/MapWriter.java create mode 100644 redisson/src/test/java/org/redisson/BaseMapTest.java diff --git a/redisson/src/main/java/org/redisson/RedissonLock.java b/redisson/src/main/java/org/redisson/RedissonLock.java index 1551d78af..2770026f5 100644 --- a/redisson/src/main/java/org/redisson/RedissonLock.java +++ b/redisson/src/main/java/org/redisson/RedissonLock.java @@ -434,6 +434,7 @@ public class RedissonLock extends RedissonExpirable implements RLock { return forceUnlockAsync(); } + @Override public RFuture unlockAsync() { long threadId = Thread.currentThread().getId(); return unlockAsync(threadId); @@ -462,6 +463,7 @@ public class RedissonLock extends RedissonExpirable implements RLock { } + @Override public RFuture unlockAsync(final long threadId) { final RPromise result = newPromise(); RFuture future = unlockInnerAsync(threadId); @@ -491,15 +493,23 @@ public class RedissonLock extends RedissonExpirable implements RLock { return result; } + @Override public RFuture lockAsync() { return lockAsync(-1, null); } - public RFuture lockAsync(final long leaseTime, final TimeUnit unit) { + @Override + public RFuture lockAsync(long leaseTime, TimeUnit unit) { final long currentThreadId = Thread.currentThread().getId(); return lockAsync(leaseTime, unit, currentThreadId); } + @Override + public RFuture lockAsync(long currentThreadId) { + return lockAsync(-1, null, currentThreadId); + } + + @Override public RFuture lockAsync(final long leaseTime, final TimeUnit unit, final long currentThreadId) { final RPromise result = newPromise(); RFuture ttlFuture = tryAcquireAsync(leaseTime, unit, currentThreadId); @@ -605,6 +615,7 @@ public class RedissonLock extends RedissonExpirable implements RLock { return tryLockAsync(Thread.currentThread().getId()); } + @Override public RFuture tryLockAsync(long threadId) { return tryAcquireOnceAsync(-1, null, threadId); } @@ -620,6 +631,7 @@ public class RedissonLock extends RedissonExpirable implements RLock { return tryLockAsync(waitTime, leaseTime, unit, currentThreadId); } + @Override public RFuture tryLockAsync(final long waitTime, final long leaseTime, final TimeUnit unit, final long currentThreadId) { final RPromise result = newPromise(); diff --git a/redisson/src/main/java/org/redisson/api/RLockAsync.java b/redisson/src/main/java/org/redisson/api/RLockAsync.java index 329c2de65..f831bb47c 100644 --- a/redisson/src/main/java/org/redisson/api/RLockAsync.java +++ b/redisson/src/main/java/org/redisson/api/RLockAsync.java @@ -30,14 +30,24 @@ public interface RLockAsync extends RExpirableAsync { RFuture unlockAsync(); + RFuture unlockAsync(long threadId); + RFuture tryLockAsync(); RFuture lockAsync(); + RFuture lockAsync(long threadId); + RFuture lockAsync(long leaseTime, TimeUnit unit); - + + RFuture lockAsync(long leaseTime, TimeUnit unit, long threadId); + + RFuture tryLockAsync(long threadId); + RFuture tryLockAsync(long waitTime, TimeUnit unit); RFuture tryLockAsync(long waitTime, long leaseTime, TimeUnit unit); + RFuture tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId); + } diff --git a/redisson/src/main/java/org/redisson/api/map/MapWriter.java b/redisson/src/main/java/org/redisson/api/map/MapWriter.java new file mode 100644 index 000000000..d76fe5397 --- /dev/null +++ b/redisson/src/main/java/org/redisson/api/map/MapWriter.java @@ -0,0 +1,38 @@ +/** + * Copyright 2016 Nikita Koksharov + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.redisson.api.map; + +import java.util.Collection; +import java.util.Map; + +/** + * + * @author Nikita Koksharov + * + * @param + * @param + */ +public interface MapWriter { + + void write(K key, V value); + + void writeAll(Map map); + + void delete(K key); + + void deleteAll(Collection keys); + +} diff --git a/redisson/src/test/java/org/redisson/BaseMapTest.java b/redisson/src/test/java/org/redisson/BaseMapTest.java new file mode 100644 index 000000000..d9420bb7b --- /dev/null +++ b/redisson/src/test/java/org/redisson/BaseMapTest.java @@ -0,0 +1,101 @@ +package org.redisson; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; + +import org.junit.Test; +import org.redisson.api.RMap; +import org.redisson.api.map.MapLoader; + +public abstract class BaseMapTest extends BaseTest { + + protected abstract RMap getLoaderTestMap(String name, Map map); + + @Test + public void testLoadAllReplaceValues() { + Map cache = new HashMap(); + for (int i = 0; i < 10; i++) { + cache.put("" + i, "" + i + "" + i); + } + + RMap map = getLoaderTestMap("test", cache); + + map.put("0", "010"); + map.put("5", "555"); + map.loadAll(false, 2); + assertThat(map.size()).isEqualTo(10); + assertThat(map.get("0")).isEqualTo("010"); + assertThat(map.get("5")).isEqualTo("555"); + map.clear(); + + map.put("0", "010"); + map.put("5", "555"); + map.loadAll(true, 2); + assertThat(map.size()).isEqualTo(10); + assertThat(map.get("0")).isEqualTo("00"); + assertThat(map.get("5")).isEqualTo("55"); + } + + @Test + public void testLoadAll() { + Map cache = new HashMap(); + for (int i = 0; i < 100; i++) { + cache.put("" + i, "" + (i*10 + i)); + } + + RMap map = getLoaderTestMap("test", cache); + + assertThat(map.size()).isEqualTo(0); + map.loadAll(false, 2); + assertThat(map.size()).isEqualTo(100); + + for (int i = 0; i < 100; i++) { + assertThat(map.containsKey("" + i)).isTrue(); + } + } + + protected MapLoader createMapLoader(Map map) { + return new MapLoader() { + @Override + public V load(K key) { + return map.get(key); + } + + @Override + public Iterable loadAllKeys() { + return map.keySet(); + } + }; + } + + @Test + public void testMapLoaderGet() { + Map cache = new HashMap(); + cache.put("1", "11"); + cache.put("2", "22"); + cache.put("3", "33"); + + RMap map = getLoaderTestMap("test", cache); + + assertThat(map.size()).isEqualTo(0); + assertThat(map.get("1")).isEqualTo("11"); + assertThat(map.size()).isEqualTo(1); + assertThat(map.get("0")).isNull(); + map.put("0", "00"); + assertThat(map.get("0")).isEqualTo("00"); + assertThat(map.size()).isEqualTo(2); + + Map s = map.getAll(new HashSet<>(Arrays.asList("1", "2", "9", "3"))); + Map expectedMap = new HashMap<>(); + expectedMap.put("1", "11"); + expectedMap.put("2", "22"); + expectedMap.put("3", "33"); + assertThat(s).isEqualTo(expectedMap); + assertThat(map.size()).isEqualTo(4); + } + +}