mport com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import org.redisson.Redisson;
import org.redisson.api.*;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.redisson.config.TransportMode;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class RedissonTest {
@Test
public void testAtomic() {
RedissonClient client = createClient();
RAtomicLong rAtomicLong = client.getAtomicLong("RAtomicLong");
Callable<Long> callable = () -> {
String threadName = Thread.currentThread().getName();
// test
long count = rAtomicLong.addAndGet(1);
System.out.printf("thread:{%s} >>> %d\n", threadName, count);
return count;
};
try {
ThreadPool.invoke(callable, 100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
ThreadPool.shutdown();
}
// selfLock();
}
@Test
public void testSet() {
RedissonClient client = createClient();
RSet<Object> rSet = client.getSet("RSet");
Callable<CompletionStage<Void>> callable = () -> {
return rSet.addAllAsync(Set.of("swimming", "coding"))
.thenAccept(v -> {
if (v == Boolean.FALSE) {
System.out.printf("[fail]thread:{%s} >>> %s\n", Thread.currentThread().getName(), v);
}
})
.exceptionally(e -> {
System.out.printf("[error]thread:{%s} >>> %s\n", Thread.currentThread().getName(), e);
return null;
});
};
try {
ThreadPool.invoke(callable, 100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
ThreadPool.shutdown();
}
}
@Test
public void testMap() {
RedissonClient client = createClient();
RMap<Object, Object> rMap = client.getMap("RMap", MapOptions.defaults());
Callable<CompletionStage<Void>> callable = () -> {
return rMap.putAllAsync(Map.of("chinese", 95, "math", 92, "english", 91))
.exceptionally(e -> {
System.out.printf("[error]thread:{%s} >>> %s\n", Thread.currentThread().getName(), e);
return null;
});
};
try {
ThreadPool.invoke(callable, 100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
ThreadPool.shutdown();
}
}
@Test
public void testLock() {
RedissonClient client = createClient();
RLock rLock = client.getLock("RLock");
Map<String, Integer> map = new HashMap<>() {{
put("number", 0);
}};
Callable<Void> callable = () -> {
rLock.lock();
try {
map.put("number", map.get("number") + 1);
} finally {
rLock.unlock();
}
return null;
};
try {
ThreadPool.invoke(callable, 100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
ThreadPool.shutdown();
}
System.out.println("number=" + map.get("number"));
}
private void selfLock() {
try {
Thread.currentThread().join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private RedissonClient createClient() {
Config config = new Config();
// EPOLL 只能在 Linux 下使用
config.setTransportMode(TransportMode.NIO);
config.useSingleServer()
.setAddress("redis://localhost:63799")
.setDatabase(0)
.setClientName("redisson-test")
.setConnectionPoolSize(128)
.setConnectionMinimumIdleSize(128)
.setIdleConnectionTimeout(60000)
.setConnectTimeout(1000)
.setTimeout(3000)
.setRetryAttempts(1);
config.setCodec(new JsonJacksonCodec(new ObjectMapper()));
config.setNettyThreads(128).setThreads(128);
return Redisson.create(config);
}
@Test
public void testBloomFilter() {
RedissonClient client = createClient();
RBloomFilter<Object> bloomFilter = client.getBloomFilter("bloomFilter");
bloomFilter.tryInit(10, 0.01);
Map<String, String> map = Map.of("a", "aa", "b", "b");
List<Integer> list = List.of(1, 11, 111);
bloomFilter.add(map);
bloomFilter.add(list);
bloomFilter.add(true);
bloomFilter.add("bloomFilter");
System.out.println("contains true=" + bloomFilter.contains(true));
System.out.println("contains false=" + bloomFilter.contains(false));
System.out.println("contains map=" + bloomFilter.contains(map));
System.out.println("contains list=" + bloomFilter.contains(list));
System.out.println("size=" + bloomFilter.getSize());
System.out.println("count=" + bloomFilter.count());
}
abstract static class ThreadPool {
private volatile static ThreadPoolExecutor executor;
private static void initThreadPool() {
executor = ThreadPoolHolder.INSTANCE;
}
public static <R> List<Future<R>> invoke(Callable<R> callable, int nRepeat) throws InterruptedException {
return invoke(callable, nRepeat, 0, TimeUnit.SECONDS);
}
public static <R> List<Future<R>> invoke(Callable<R> callable, int nRepeat, long timeout, TimeUnit unit) throws InterruptedException {
if (executor == null) {
initThreadPool();
}
List<Callable<R>> callables = IntStream.range(0, nRepeat).boxed().map(i -> callable).collect(Collectors.toList());
if (timeout <= 0) {
return executor.invokeAll(callables);
}
return executor.invokeAll(callables, timeout, unit);
}
private static class ThreadPoolHolder {
private final static ThreadPoolExecutor INSTANCE =
new ThreadPoolExecutor(128, 128, 0, TimeUnit.SECONDS,
new LinkedBlockingQueue<>());
}
public static void shutdown() {
if (executor != null && !executor.isShutdown()) {
executor.shutdown();
}
executor = null;
}
}
}
Redisson 测试
最后编辑于 :
©著作权归作者所有,转载或内容合作请联系作者
- 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
- 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
- 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
推荐阅读更多精彩内容
- Markdown 是一种轻量级标记语言,它允许人们使用易读易写的纯文本格式编写文档,然后转换成格式丰富的HTML页...
- 小白板:评论的附件功能;评论通知跳转评论页面; IM:公司/团队/已解散群组的标识;附件上传及预览;置顶;消息免打...
- 4️月工作坊结束大约有半个月了,其间具体学了什么似乎很难记清楚,但中间对自己有很多的看见,也有很多感动人的感受至今...