Merge branch 'master' of https://github.com/mrniko/redisson into redisson-reference
# Conflicts: # redisson/pom.xml # redisson/src/main/java/org/redisson/command/CommandAsyncExecutor.java # redisson/src/main/java/org/redisson/command/CommandAsyncService.javapull/605/head
jackygurui
9 years ago
commit
62042c4b95
@ -0,0 +1,5 @@
|
||||
## Redisson standalone node
|
||||
|
||||
Redisson offers ability to run as standalone node and participate in distributed computing. Such standalone nodes could be used to run [ExecutorService](./9.-distributed-services#93-executor-service), [ScheduledExecutorService](https://github.com/mrniko/redisson/wiki/9.-distributed-services#94-scheduled-executor-service) tasks or [RemoteService](./9.-distributed-services#91-remote-service) services. It's just a single jar and could be downloaded from [here](https://repository.sonatype.org/service/local/artifact/maven/redirect?r=central-proxy&g=org.redisson&a=redisson-all&v=2.3.0&e=jar)
|
||||
|
||||
[Documentation](https://github.com/mrniko/redisson/wiki/12.-Standalone-node) about Redisson standalone node.
|
||||
@ -0,0 +1,690 @@
|
||||
/**
|
||||
* 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;
|
||||
|
||||
import java.util.AbstractCollection;
|
||||
import java.util.AbstractMap;
|
||||
import java.util.AbstractSet;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
|
||||
import org.redisson.api.LocalCachedMapOptions;
|
||||
import org.redisson.api.LocalCachedMapOptions.EvictionPolicy;
|
||||
import org.redisson.api.RFuture;
|
||||
import org.redisson.api.RLocalCachedMap;
|
||||
import org.redisson.api.RMap;
|
||||
import org.redisson.api.RTopic;
|
||||
import org.redisson.api.RedissonClient;
|
||||
import org.redisson.api.listener.MessageListener;
|
||||
import org.redisson.client.codec.Codec;
|
||||
import org.redisson.client.codec.LongCodec;
|
||||
import org.redisson.client.protocol.RedisCommand;
|
||||
import org.redisson.client.protocol.RedisCommand.ValueType;
|
||||
import org.redisson.client.protocol.RedisCommands;
|
||||
import org.redisson.command.CommandAsyncExecutor;
|
||||
import org.redisson.misc.Cache;
|
||||
import org.redisson.misc.Hash;
|
||||
import org.redisson.misc.LFUCacheMap;
|
||||
import org.redisson.misc.LRUCacheMap;
|
||||
import org.redisson.misc.NoneCacheMap;
|
||||
|
||||
import io.netty.util.concurrent.Future;
|
||||
import io.netty.util.concurrent.FutureListener;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
*/
|
||||
public class RedissonLocalCachedMap<K, V> extends RedissonExpirable implements RLocalCachedMap<K, V> {
|
||||
|
||||
public static class LocalCachedMapClear {
|
||||
|
||||
}
|
||||
|
||||
public static class LocalCachedMapInvalidate {
|
||||
|
||||
private byte[] keyHash;
|
||||
|
||||
public LocalCachedMapInvalidate() {
|
||||
}
|
||||
|
||||
public LocalCachedMapInvalidate(byte[] keyHash) {
|
||||
super();
|
||||
this.keyHash = keyHash;
|
||||
}
|
||||
|
||||
public byte[] getKeyHash() {
|
||||
return keyHash;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static class CacheKey {
|
||||
|
||||
private final byte[] keyHash;
|
||||
|
||||
public CacheKey(byte[] keyHash) {
|
||||
super();
|
||||
this.keyHash = keyHash;
|
||||
}
|
||||
|
||||
public byte[] getKeyHash() {
|
||||
return keyHash;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
result = prime * result + Arrays.hashCode(keyHash);
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj)
|
||||
return true;
|
||||
if (obj == null)
|
||||
return false;
|
||||
if (getClass() != obj.getClass())
|
||||
return false;
|
||||
CacheKey other = (CacheKey) obj;
|
||||
if (!Arrays.equals(keyHash, other.keyHash))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "CacheKey [keyHash=" + Arrays.toString(keyHash) + "]";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static class CacheValue {
|
||||
|
||||
private final Object key;
|
||||
private final Object value;
|
||||
|
||||
public CacheValue(Object key, Object value) {
|
||||
super();
|
||||
this.key = key;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public Object getKey() {
|
||||
return key;
|
||||
}
|
||||
|
||||
public Object getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj)
|
||||
return true;
|
||||
if (obj == null)
|
||||
return false;
|
||||
if (getClass() != obj.getClass())
|
||||
return false;
|
||||
CacheValue other = (CacheValue) obj;
|
||||
if (value == null) {
|
||||
if (other.value != null)
|
||||
return false;
|
||||
} else if (!value.equals(other.value))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "CacheValue [key=" + key + ", value=" + value + "]";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private static final RedisCommand<Object> EVAL_PUT = new RedisCommand<Object>("EVAL", -1, ValueType.OBJECT, ValueType.MAP_VALUE);
|
||||
private static final RedisCommand<Object> EVAL_REMOVE = new RedisCommand<Object>("EVAL", -1, ValueType.OBJECT, ValueType.MAP_VALUE);
|
||||
|
||||
private RTopic<Object> invalidationTopic;
|
||||
private RMap<K, V> map;
|
||||
private Cache<CacheKey, CacheValue> cache;
|
||||
private int invalidateEntryOnChange;
|
||||
|
||||
protected RedissonLocalCachedMap(RedissonClient redisson, CommandAsyncExecutor commandExecutor, String name, LocalCachedMapOptions options) {
|
||||
super(commandExecutor, name);
|
||||
init(redisson, name, options);
|
||||
}
|
||||
|
||||
protected RedissonLocalCachedMap(RedissonClient redisson, Codec codec, CommandAsyncExecutor connectionManager, String name, LocalCachedMapOptions options) {
|
||||
super(codec, connectionManager, name);
|
||||
init(redisson, name, options);
|
||||
}
|
||||
|
||||
private void init(RedissonClient redisson, String name, LocalCachedMapOptions options) {
|
||||
map = redisson.getMap(name);
|
||||
|
||||
if (options.isInvalidateEntryOnChange()) {
|
||||
invalidateEntryOnChange = 1;
|
||||
}
|
||||
if (options.getEvictionPolicy() == EvictionPolicy.NONE) {
|
||||
cache = new NoneCacheMap<CacheKey, CacheValue>(options.getTimeToLiveInMillis(), options.getMaxIdleInMillis());
|
||||
}
|
||||
if (options.getEvictionPolicy() == EvictionPolicy.LRU) {
|
||||
cache = new LRUCacheMap<CacheKey, CacheValue>(options.getCacheSize(), options.getTimeToLiveInMillis(), options.getMaxIdleInMillis());
|
||||
}
|
||||
if (options.getEvictionPolicy() == EvictionPolicy.LFU) {
|
||||
cache = new LFUCacheMap<CacheKey, CacheValue>(options.getCacheSize(), options.getTimeToLiveInMillis(), options.getMaxIdleInMillis());
|
||||
}
|
||||
|
||||
invalidationTopic = redisson.getTopic(name + ":topic");
|
||||
invalidationTopic.addListener(new MessageListener<Object>() {
|
||||
@Override
|
||||
public void onMessage(String channel, Object msg) {
|
||||
if (msg instanceof LocalCachedMapClear) {
|
||||
cache.clear();
|
||||
}
|
||||
if (msg instanceof LocalCachedMapInvalidate) {
|
||||
CacheKey key = new CacheKey(((LocalCachedMapInvalidate)msg).getKeyHash());
|
||||
cache.remove(key);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return get(sizeAsync());
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Integer> sizeAsync() {
|
||||
return map.sizeAsync();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return map.isEmpty();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsKey(Object key) {
|
||||
return get(containsKeyAsync(key));
|
||||
}
|
||||
|
||||
private CacheKey toCacheKey(Object key) {
|
||||
byte[] encoded = encodeMapKey(key);
|
||||
return toCacheKey(encoded);
|
||||
}
|
||||
|
||||
private CacheKey toCacheKey(byte[] encodedKey) {
|
||||
return new CacheKey(Hash.hash(encodedKey));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Boolean> containsKeyAsync(Object key) {
|
||||
CacheKey cacheKey = toCacheKey(key);
|
||||
if (!cache.containsKey(cacheKey)) {
|
||||
return map.containsKeyAsync(key);
|
||||
}
|
||||
return newSucceededFuture(true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsValue(Object value) {
|
||||
return get(containsValueAsync(value));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Boolean> containsValueAsync(Object value) {
|
||||
CacheValue cacheValue = new CacheValue(null, value);
|
||||
if (!cache.containsValue(cacheValue)) {
|
||||
return map.containsValueAsync(value);
|
||||
}
|
||||
return newSucceededFuture(true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public V get(Object key) {
|
||||
return get(getAsync(key));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<V> getAsync(final Object key) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
final CacheKey cacheKey = toCacheKey(key);
|
||||
CacheValue cacheValue = cache.get(cacheKey);
|
||||
if (cacheValue != null && cacheValue.getValue() != null) {
|
||||
return newSucceededFuture((V)cacheValue.getValue());
|
||||
}
|
||||
|
||||
RFuture<V> future = map.getAsync((K)key);
|
||||
future.addListener(new FutureListener<V>() {
|
||||
@Override
|
||||
public void operationComplete(Future<V> future) throws Exception {
|
||||
if (!future.isSuccess()) {
|
||||
return;
|
||||
}
|
||||
|
||||
V value = future.getNow();
|
||||
if (value != null) {
|
||||
cache.put(cacheKey, new CacheValue(key, value));
|
||||
}
|
||||
}
|
||||
});
|
||||
return future;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public V put(K key, V value) {
|
||||
return get(putAsync(key, value));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<V> putAsync(K key, V value) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
if (value == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
byte[] mapKey = encodeMapKey(key);
|
||||
CacheKey cacheKey = toCacheKey(mapKey);
|
||||
byte[] msg = encode(new LocalCachedMapInvalidate(cacheKey.getKeyHash()));
|
||||
CacheValue cacheValue = new CacheValue(key, value);
|
||||
cache.put(cacheKey, cacheValue);
|
||||
return commandExecutor.evalWriteAsync(getName(), codec, EVAL_PUT,
|
||||
"local v = redis.call('hget', KEYS[1], ARGV[1]); "
|
||||
+ "if redis.call('hset', KEYS[1], ARGV[1], ARGV[2]) == 0 and ARGV[4] == '1' then "
|
||||
+ "redis.call('publish', KEYS[2], ARGV[3]); "
|
||||
+ "end; "
|
||||
+ "return v; ",
|
||||
Arrays.<Object>asList(getName(), invalidationTopic.getChannelNames().get(0)),
|
||||
mapKey, encodeMapValue(value), msg, invalidateEntryOnChange);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean fastPut(K key, V value) {
|
||||
return get(fastPutAsync(key, value));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Boolean> fastPutAsync(K key, V value) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
if (value == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
byte[] encodedKey = encodeMapKey(key);
|
||||
byte[] encodedValue = encodeMapKey(value);
|
||||
CacheKey cacheKey = toCacheKey(encodedKey);
|
||||
byte[] msg = encode(new LocalCachedMapInvalidate(cacheKey.getKeyHash()));
|
||||
CacheValue cacheValue = new CacheValue(key, value);
|
||||
cache.put(cacheKey, cacheValue);
|
||||
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
|
||||
"if redis.call('hset', KEYS[1], ARGV[1], ARGV[2]) == 0 then "
|
||||
+ "if ARGV[4] == '1' then "
|
||||
+ "redis.call('publish', KEYS[2], ARGV[3]); "
|
||||
+ "end;"
|
||||
+ "return 0; "
|
||||
+ "end; "
|
||||
+ "return 1; ",
|
||||
Arrays.<Object>asList(getName(), invalidationTopic.getChannelNames().get(0)),
|
||||
encodedKey, encodedValue, msg, invalidateEntryOnChange);
|
||||
}
|
||||
|
||||
@Override
|
||||
public V remove(Object key) {
|
||||
return get(removeAsync((K)key));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<V> removeAsync(K key) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
byte[] keyEncoded = encodeMapKey(key);
|
||||
CacheKey cacheKey = toCacheKey(keyEncoded);
|
||||
byte[] msgEncoded = encode(new LocalCachedMapInvalidate(cacheKey.getKeyHash()));
|
||||
cache.remove(cacheKey);
|
||||
return commandExecutor.evalWriteAsync(getName(), codec, EVAL_REMOVE,
|
||||
"local v = redis.call('hget', KEYS[1], ARGV[1]); "
|
||||
+ "if redis.call('hdel', KEYS[1], ARGV[1]) == 1 and ARGV[3] == '1' then "
|
||||
+ "redis.call('publish', KEYS[2], ARGV[2]); "
|
||||
+ "end; "
|
||||
+ "return v",
|
||||
Arrays.<Object>asList(getName(), invalidationTopic.getChannelNames().get(0)),
|
||||
keyEncoded, msgEncoded, invalidateEntryOnChange);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean fastRemove(Object key) {
|
||||
return get(fastRemoveAsync((K)key));
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Boolean> fastRemoveAsync(K key) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
byte[] keyEncoded = encodeMapKey(key);
|
||||
CacheKey cacheKey = toCacheKey(keyEncoded);
|
||||
byte[] msgEncoded = encode(new LocalCachedMapInvalidate(cacheKey.getKeyHash()));
|
||||
cache.remove(cacheKey);
|
||||
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
|
||||
"if redis.call('hdel', KEYS[1], ARGV[1]) == 1 then "
|
||||
+ "if ARGV[3] == '1' then "
|
||||
+ "redis.call('publish', KEYS[2], ARGV[2]); "
|
||||
+ "end; "
|
||||
+ "return 1;"
|
||||
+ "end;"
|
||||
+ "return 0;",
|
||||
Arrays.<Object>asList(getName(), invalidationTopic.getChannelNames().get(0)),
|
||||
keyEncoded, msgEncoded, invalidateEntryOnChange);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void putAll(Map<? extends K, ? extends V> m) {
|
||||
Map<CacheKey, CacheValue> cacheMap = new HashMap<CacheKey, CacheValue>(m.size());
|
||||
for (java.util.Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
|
||||
CacheKey cacheKey = toCacheKey(entry.getKey());
|
||||
CacheValue cacheValue = new CacheValue(entry.getKey(), entry.getValue());
|
||||
cacheMap.put(cacheKey, cacheValue);
|
||||
}
|
||||
cache.putAll(cacheMap);
|
||||
map.putAll(m);
|
||||
for (CacheKey cacheKey : cacheMap.keySet()) {
|
||||
invalidationTopic.publish(new LocalCachedMapInvalidate(cacheKey.getKeyHash()));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
delete();
|
||||
}
|
||||
|
||||
@Override
|
||||
public RFuture<Boolean> deleteAsync() {
|
||||
cache.clear();
|
||||
byte[] msgEncoded = encode(new LocalCachedMapClear());
|
||||
return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
|
||||
"if redis.call('del', KEYS[1]) == 1 and ARGV[2] == '1' then "
|
||||
+ "redis.call('publish', KEYS[2], ARGV[1]); "
|
||||
+ "end; ",
|
||||
Arrays.<Object>asList(getName(), invalidationTopic.getChannelNames().get(0)),
|
||||
msgEncoded, invalidateEntryOnChange);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<K> keySet() {
|
||||
return new KeySet();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<V> values() {
|
||||
return new Values();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<java.util.Map.Entry<K, V>> entrySet() {
|
||||
return new EntrySet();
|
||||
}
|
||||
|
||||
private Iterator<Map.Entry<K,V>> cacheEntrySetIterator() {
|
||||
final Iterator<Map.Entry<CacheKey, CacheValue>> iter = cache.entrySet().iterator();
|
||||
|
||||
return new Iterator<Map.Entry<K,V>>() {
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return iter.hasNext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.Map.Entry<K, V> next() {
|
||||
Map.Entry<CacheKey, CacheValue> entry = iter.next();
|
||||
return new AbstractMap.SimpleEntry(entry.getValue().getKey(), entry.getValue().getValue());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
iter.remove();
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
private Iterator<K> cacheKeySetIterator() {
|
||||
final Iterator<CacheValue> iter = cache.values().iterator();
|
||||
|
||||
return new Iterator<K>() {
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return iter.hasNext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public K next() {
|
||||
CacheValue value = iter.next();
|
||||
return (K) value.getKey();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
iter.remove();
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
final class KeySet extends AbstractSet<K> {
|
||||
|
||||
@Override
|
||||
public Iterator<K> iterator() {
|
||||
return new CompositeIterable<K>(cacheKeySetIterator(), map.keySet().iterator()) {
|
||||
|
||||
@Override
|
||||
boolean isCacheContains(Object object) {
|
||||
CacheKey cacheKey = toCacheKey(object);
|
||||
return cache.containsKey(cacheKey);
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
return RedissonLocalCachedMap.this.containsKey(o);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean remove(Object o) {
|
||||
return RedissonLocalCachedMap.this.remove(o) != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return RedissonLocalCachedMap.this.size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
RedissonLocalCachedMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final class Values extends AbstractCollection<V> {
|
||||
|
||||
@Override
|
||||
public Iterator<V> iterator() {
|
||||
final Iterator<Map.Entry<K, V>> iter = RedissonLocalCachedMap.this.entrySet().iterator();
|
||||
return new Iterator<V>() {
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return iter.hasNext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public V next() {
|
||||
return iter.next().getValue();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
iter.remove();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
return RedissonLocalCachedMap.this.containsValue(o);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return RedissonLocalCachedMap.this.size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
RedissonLocalCachedMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
|
||||
|
||||
public final Iterator<Map.Entry<K,V>> iterator() {
|
||||
return new CompositeIterable<Map.Entry<K,V>>(cacheEntrySetIterator(), map.entrySet().iterator()) {
|
||||
|
||||
@Override
|
||||
boolean isCacheContains(Map.Entry<K,V> entry) {
|
||||
CacheKey cacheKey = toCacheKey(entry.getKey());
|
||||
return cache.containsKey(cacheKey);
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
public final boolean contains(Object o) {
|
||||
if (!(o instanceof Map.Entry))
|
||||
return false;
|
||||
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
|
||||
Object key = e.getKey();
|
||||
V value = get(key);
|
||||
return value != null && value.equals(e);
|
||||
}
|
||||
|
||||
public final boolean remove(Object o) {
|
||||
if (o instanceof Map.Entry) {
|
||||
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
|
||||
Object key = e.getKey();
|
||||
Object value = e.getValue();
|
||||
return RedissonLocalCachedMap.this.map.remove(key, value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public final int size() {
|
||||
return RedissonLocalCachedMap.this.size();
|
||||
}
|
||||
|
||||
public final void clear() {
|
||||
RedissonLocalCachedMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
abstract class CompositeIterable<T> implements Iterator<T> {
|
||||
|
||||
private T currentObject;
|
||||
private Iterator<T> cacheIterator;
|
||||
private Iterator<T> mapIterator;
|
||||
|
||||
public CompositeIterable(Iterator<T> cacheIterator, Iterator<T> mapIterator) {
|
||||
this.cacheIterator = cacheIterator;
|
||||
this.mapIterator = mapIterator;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
if (!cacheIterator.hasNext()) {
|
||||
while (true) {
|
||||
if (mapIterator.hasNext()) {
|
||||
currentObject = mapIterator.next();
|
||||
if (!isCacheContains(currentObject)) {
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
abstract boolean isCacheContains(T object);
|
||||
|
||||
@Override
|
||||
public T next() {
|
||||
if (currentObject != null) {
|
||||
T val = currentObject;
|
||||
currentObject = null;
|
||||
return val;
|
||||
}
|
||||
if (!hasNext()) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
return cacheIterator.next();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if (currentObject != null) {
|
||||
mapIterator.remove();
|
||||
currentObject = null;
|
||||
return;
|
||||
}
|
||||
|
||||
cacheIterator.remove();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,174 @@
|
||||
/**
|
||||
* 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;
|
||||
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
* RLocalCachedMap options object. Used to specify RLocalCachedMap settings.
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
*/
|
||||
public class LocalCachedMapOptions {
|
||||
|
||||
public enum EvictionPolicy {NONE, LRU, LFU};
|
||||
|
||||
private boolean invalidateEntryOnChange;
|
||||
private EvictionPolicy evictionPolicy;
|
||||
private int cacheSize;
|
||||
private long timeToLiveInMillis;
|
||||
private long maxIdleInMillis;
|
||||
|
||||
private LocalCachedMapOptions() {
|
||||
}
|
||||
|
||||
protected LocalCachedMapOptions(LocalCachedMapOptions copy) {
|
||||
this.invalidateEntryOnChange = copy.invalidateEntryOnChange;
|
||||
this.evictionPolicy = copy.evictionPolicy;
|
||||
this.cacheSize = copy.cacheSize;
|
||||
this.timeToLiveInMillis = copy.timeToLiveInMillis;
|
||||
this.maxIdleInMillis = copy.maxIdleInMillis;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new instance of LocalCachedMapOptions with default options.
|
||||
* <p/>
|
||||
* This is equivalent to:
|
||||
* <pre>
|
||||
* new LocalCachedMapOptions()
|
||||
* .cacheSize(0).timeToLive(0).maxIdle(0)
|
||||
* .evictionPolicy(EvictionPolicy.NONE)
|
||||
* .invalidateEntryOnChange(true);
|
||||
* </pre>
|
||||
*/
|
||||
public static LocalCachedMapOptions defaults() {
|
||||
return new LocalCachedMapOptions()
|
||||
.cacheSize(0).timeToLive(0).maxIdle(0)
|
||||
.evictionPolicy(EvictionPolicy.NONE)
|
||||
.invalidateEntryOnChange(true);
|
||||
}
|
||||
|
||||
public boolean isInvalidateEntryOnChange() {
|
||||
return invalidateEntryOnChange;
|
||||
}
|
||||
|
||||
public EvictionPolicy getEvictionPolicy() {
|
||||
return evictionPolicy;
|
||||
}
|
||||
|
||||
public int getCacheSize() {
|
||||
return cacheSize;
|
||||
}
|
||||
|
||||
public long getTimeToLiveInMillis() {
|
||||
return timeToLiveInMillis;
|
||||
}
|
||||
|
||||
public long getMaxIdleInMillis() {
|
||||
return maxIdleInMillis;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets cache size. If size is <code>0</code> then cache is unbounded.
|
||||
*
|
||||
* @param cacheSize
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions cacheSize(int cacheSize) {
|
||||
this.cacheSize = cacheSize;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets entry invalidation behavior.
|
||||
*
|
||||
* @param value - if <code>true</code> then invalidation message which removes corresponding entry from cache
|
||||
* will be sent to all other RLocalCachedMap instances on each entry update/remove operation.
|
||||
* if <code>false</code> then invalidation message won't be sent
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions invalidateEntryOnChange(boolean value) {
|
||||
this.invalidateEntryOnChange = value;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets eviction policy.
|
||||
*
|
||||
* @param evictionPolicy
|
||||
* <p><code>LRU</code> - uses cache with LRU (least recently used) eviction policy.
|
||||
* <p><code>LFU</code> - uses cache with LFU (least frequently used) eviction policy.
|
||||
* <p><code>NONE</code> - doesn't use eviction policy, but timeToLive and maxIdleTime params are still working.
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions evictionPolicy(EvictionPolicy evictionPolicy) {
|
||||
if (evictionPolicy == null) {
|
||||
throw new NullPointerException("evictionPolicy can't be null");
|
||||
}
|
||||
this.evictionPolicy = evictionPolicy;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets time to live in milliseconds for each map entry in cache.
|
||||
* If value equals to <code>0<code> then timeout is not applied
|
||||
*
|
||||
* @param timeToLiveInMillis
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions timeToLive(long timeToLiveInMillis) {
|
||||
this.timeToLiveInMillis = timeToLiveInMillis;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets time to live for each map entry in cache.
|
||||
* If value equals to <code>0<code> then timeout is not applied
|
||||
*
|
||||
* @param timeToLive
|
||||
* @param timeUnit
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions timeToLive(long timeToLive, TimeUnit timeUnit) {
|
||||
return timeToLive(timeUnit.toMillis(timeToLive));
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets max idle time in milliseconds for each map entry in cache.
|
||||
* If value equals to <code>0<code> then timeout is not applied
|
||||
*
|
||||
* @param maxIdleInMillis
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions maxIdle(long maxIdleInMillis) {
|
||||
this.maxIdleInMillis = maxIdleInMillis;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets max idle time for each map entry in cache.
|
||||
* If value equals to <code>0<code> then timeout is not applied
|
||||
*
|
||||
* @param maxIdleInMillis
|
||||
* @return
|
||||
*/
|
||||
public LocalCachedMapOptions maxIdle(long maxIdle, TimeUnit timeUnit) {
|
||||
return timeToLive(timeUnit.toMillis(maxIdle));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
/**
|
||||
* 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;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Map object with entry cache support.
|
||||
* <p>
|
||||
* Each instance maintains local cache to achieve fast read operations.
|
||||
* Suitable for maps which used mostly for read operations and network roundtrip delays are undesirable.
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public interface RLocalCachedMap<K, V> extends Map<K, V>, RExpirable, RLocalCachedMapAsync<K, V> {
|
||||
|
||||
/**
|
||||
* Associates the specified <code>value</code> with the specified <code>key</code>.
|
||||
* <p>
|
||||
* Works faster than <code>RLocalCachedMap.put</code> but not returning
|
||||
* the previous value associated with <code>key</code>
|
||||
*
|
||||
* @param key
|
||||
* @param value
|
||||
* @return <code>true</code> if key is a new key in the hash and value was set.
|
||||
* <code>false</code> if key already exists in the hash and the value was updated.
|
||||
*/
|
||||
boolean fastPut(K key, V value);
|
||||
|
||||
/**
|
||||
* Removes <code>key</code> from map
|
||||
* <p>
|
||||
* Works faster than <code>RLocalCachedMap.remove</code> but not returning
|
||||
* the value associated with <code>key</code>
|
||||
*
|
||||
* @param key
|
||||
* @return <code>true</code> if key has been deleted.
|
||||
* <code>false</code> if key doesn't exist.
|
||||
*/
|
||||
boolean fastRemove(Object key);
|
||||
|
||||
}
|
||||
@ -0,0 +1,100 @@
|
||||
/**
|
||||
* 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;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public interface RLocalCachedMapAsync<K, V> extends RExpirableAsync {
|
||||
|
||||
/**
|
||||
* Returns map size
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
RFuture<Integer> sizeAsync();
|
||||
|
||||
/**
|
||||
* Checks if map contains the specified <code>key</code>
|
||||
*
|
||||
* @return <code>true</code> if map contains <code>key</code>.
|
||||
* <code>false</code> if map doesn't contain <code>key</code>.
|
||||
*/
|
||||
RFuture<Boolean> containsKeyAsync(Object key);
|
||||
|
||||
/**
|
||||
* Checks if map contains the specified <code>value</code>
|
||||
*
|
||||
* @return <code>true</code> if map contains <code>value</code>.
|
||||
* <code>false</code> if map doesn't contain <code>value</code>.
|
||||
*/
|
||||
RFuture<Boolean> containsValueAsync(Object value);
|
||||
|
||||
/**
|
||||
* Returns value associated with <code>key</code>
|
||||
*
|
||||
* @param key
|
||||
* @return
|
||||
*/
|
||||
RFuture<V> getAsync(Object key);
|
||||
|
||||
/**
|
||||
* Associates the specified <code>value</code> with the specified <code>key</code>.
|
||||
*
|
||||
* @param key
|
||||
* @param value
|
||||
* @return previous value associated with <code>key</code>
|
||||
*/
|
||||
RFuture<V> putAsync(K key, V value);
|
||||
|
||||
/**
|
||||
* Removes <code>key</code> from map.
|
||||
*
|
||||
* @param key
|
||||
* @return removed value associated with <code>key</code>
|
||||
*/
|
||||
RFuture<V> removeAsync(K key);
|
||||
|
||||
/**
|
||||
* Removes <code>key</code> from map
|
||||
* <p>
|
||||
* Works faster than <code>RLocalCachedMap.remove</code> but not returning
|
||||
* the value associated with <code>key</code>
|
||||
*
|
||||
* @param key
|
||||
* @return <code>true</code> if key has been deleted.
|
||||
* <code>false</code> if key doesn't exist.
|
||||
*/
|
||||
RFuture<Boolean> fastRemoveAsync(K key);
|
||||
|
||||
/**
|
||||
* Associates the specified <code>value</code> with the specified <code>key</code>.
|
||||
* <p>
|
||||
* Works faster than <code>RLocalCachedMap.put</code> but not returning
|
||||
* the previous value associated with <code>key</code>
|
||||
*
|
||||
* @param key
|
||||
* @param value
|
||||
* @return <code>true</code> if key is a new key in the hash and value was set.
|
||||
* <code>false</code> if key already exists in the hash and the value was updated.
|
||||
*/
|
||||
RFuture<Boolean> fastPutAsync(K key, V value);
|
||||
|
||||
}
|
||||
@ -0,0 +1,520 @@
|
||||
/**
|
||||
* 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.misc;
|
||||
|
||||
import java.util.AbstractCollection;
|
||||
import java.util.AbstractMap.SimpleEntry;
|
||||
import java.util.AbstractSet;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import io.netty.util.internal.PlatformDependent;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public abstract class AbstractCacheMap<K, V> implements Cache<K, V> {
|
||||
|
||||
public static class CachedValue {
|
||||
|
||||
private final Object key;
|
||||
private final Object value;
|
||||
|
||||
long ttl;
|
||||
long maxIdleTime;
|
||||
|
||||
long creationTime;
|
||||
long lastAccess;
|
||||
|
||||
public CachedValue(Object key, Object value, long ttl, long maxIdleTime) {
|
||||
this.value = value;
|
||||
this.ttl = ttl;
|
||||
this.key = key;
|
||||
this.maxIdleTime = maxIdleTime;
|
||||
creationTime = System.currentTimeMillis();
|
||||
lastAccess = creationTime;
|
||||
}
|
||||
|
||||
public boolean isExpired() {
|
||||
boolean result = false;
|
||||
long currentTime = System.currentTimeMillis();
|
||||
if (ttl != 0 && creationTime + ttl < currentTime) {
|
||||
result = true;
|
||||
}
|
||||
if (maxIdleTime != 0 && lastAccess + maxIdleTime < currentTime) {
|
||||
result = true;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public Object getKey() {
|
||||
return key;
|
||||
}
|
||||
|
||||
public Object getValue() {
|
||||
lastAccess = System.currentTimeMillis();
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "CachedValue [key=" + key + ", value=" + value + "]";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final int size;
|
||||
final ConcurrentMap<K, CachedValue> map = PlatformDependent.newConcurrentHashMap();
|
||||
private final long timeToLiveInMillis;
|
||||
private final long maxIdleInMillis;
|
||||
|
||||
|
||||
public AbstractCacheMap(int size, long timeToLiveInMillis, long maxIdleInMillis) {
|
||||
if (size < 0) {
|
||||
throw new IllegalArgumentException("Size can't be " + size);
|
||||
}
|
||||
this.size = size;
|
||||
this.maxIdleInMillis = maxIdleInMillis;
|
||||
this.timeToLiveInMillis = timeToLiveInMillis;
|
||||
}
|
||||
|
||||
protected void onValueRead(CachedValue value) {
|
||||
|
||||
}
|
||||
|
||||
protected void onValueRemove(CachedValue value) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#size()
|
||||
*/
|
||||
@Override
|
||||
public int size() {
|
||||
return map.size();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#isEmpty()
|
||||
*/
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return map.isEmpty();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#containsKey(java.lang.Object)
|
||||
*/
|
||||
@Override
|
||||
public boolean containsKey(Object key) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
CachedValue entry = map.get(key);
|
||||
if (entry == null) {
|
||||
return false;
|
||||
}
|
||||
if (entry.isExpired()) {
|
||||
if (map.remove(key, entry)) {
|
||||
onValueRemove(entry);
|
||||
return false;
|
||||
}
|
||||
return containsKey(key);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#containsValue(java.lang.Object)
|
||||
*/
|
||||
@Override
|
||||
public boolean containsValue(Object value) {
|
||||
if (value == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
for (Map.Entry<K, CachedValue> entry : map.entrySet()) {
|
||||
CachedValue cachedValue = entry.getValue();
|
||||
if (cachedValue.getValue().equals(value)) {
|
||||
if (cachedValue.isExpired()) {
|
||||
if (map.remove(cachedValue.getKey(), cachedValue)) {
|
||||
onValueRemove(cachedValue);
|
||||
}
|
||||
} else {
|
||||
readValue(cachedValue);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#get(java.lang.Object)
|
||||
*/
|
||||
@Override
|
||||
public V get(Object key) {
|
||||
if (key == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
|
||||
CachedValue entry = map.get(key);
|
||||
if (entry == null) {
|
||||
return null;
|
||||
}
|
||||
if (entry.isExpired()) {
|
||||
if (map.remove(key, entry)) {
|
||||
onValueRemove(entry);
|
||||
return null;
|
||||
}
|
||||
return get(key);
|
||||
}
|
||||
return readValue(entry);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
protected V readValue(CachedValue entry) {
|
||||
onValueRead(entry);
|
||||
return (V) entry.getValue();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
|
||||
*/
|
||||
@Override
|
||||
public V put(K key, V value) {
|
||||
return put(key, value, timeToLiveInMillis, TimeUnit.MILLISECONDS, maxIdleInMillis, TimeUnit.MILLISECONDS);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public V put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) {
|
||||
CachedValue entry = create(key, value, ttlUnit.toMillis(ttl), maxIdleUnit.toMillis(maxIdleTime));
|
||||
if (isFull(key)) {
|
||||
if (!removeExpiredEntries()) {
|
||||
onMapFull();
|
||||
}
|
||||
}
|
||||
onValueCreate(entry);
|
||||
CachedValue prevCachedValue = map.put(key, entry);
|
||||
if (prevCachedValue != null) {
|
||||
onValueRemove(prevCachedValue);
|
||||
if (!prevCachedValue.isExpired()) {
|
||||
return (V) prevCachedValue.getValue();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected CachedValue create(K key, V value, long ttl, long maxIdleTime) {
|
||||
return new CachedValue(key, value, ttl, maxIdleTime);
|
||||
}
|
||||
|
||||
protected void onValueCreate(CachedValue entry) {
|
||||
}
|
||||
|
||||
private boolean removeExpiredEntries() {
|
||||
boolean removed = false;
|
||||
// TODO optimize
|
||||
for (CachedValue value : map.values()) {
|
||||
if (value.isExpired()) {
|
||||
if (map.remove(value.getKey(), value)) {
|
||||
onValueRemove(value);
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
protected abstract void onMapFull();
|
||||
|
||||
boolean isFull() {
|
||||
if (size == 0) {
|
||||
return false;
|
||||
}
|
||||
return map.size() >= size;
|
||||
}
|
||||
|
||||
private boolean isFull(K key) {
|
||||
if (size == 0) {
|
||||
return false;
|
||||
}
|
||||
if (map.size() >= size) {
|
||||
return !map.containsKey(key);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#remove(java.lang.Object)
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public V remove(Object key) {
|
||||
CachedValue entry = map.remove(key);
|
||||
if (entry != null) {
|
||||
onValueRemove(entry);
|
||||
if (!entry.isExpired()) {
|
||||
return (V) entry.getValue();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#putAll(java.util.Map)
|
||||
*/
|
||||
@Override
|
||||
public void putAll(Map<? extends K, ? extends V> m) {
|
||||
removeExpiredEntries();
|
||||
for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
|
||||
put(entry.getKey(), entry.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#clear()
|
||||
*/
|
||||
@Override
|
||||
public void clear() {
|
||||
map.clear();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#keySet()
|
||||
*/
|
||||
@Override
|
||||
public Set<K> keySet() {
|
||||
removeExpiredEntries();
|
||||
return new KeySet();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#values()
|
||||
*/
|
||||
@Override
|
||||
public Collection<V> values() {
|
||||
removeExpiredEntries();
|
||||
return new Values();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
* @see java.util.Map#entrySet()
|
||||
*/
|
||||
@Override
|
||||
public Set<Map.Entry<K, V>> entrySet() {
|
||||
removeExpiredEntries();
|
||||
return new EntrySet();
|
||||
}
|
||||
|
||||
abstract class MapIterator<M> implements Iterator<M> {
|
||||
|
||||
final Iterator<Map.Entry<K, CachedValue>> keyIterator = map.entrySet().iterator();
|
||||
|
||||
Map.Entry<K, CachedValue> mapEntry;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
if (mapEntry != null) {
|
||||
return true;
|
||||
}
|
||||
mapEntry = null;
|
||||
while (keyIterator.hasNext()) {
|
||||
Map.Entry<K, CachedValue> entry = keyIterator.next();
|
||||
if (entry.getValue().isExpired()) {
|
||||
continue;
|
||||
}
|
||||
mapEntry = entry;
|
||||
break;
|
||||
}
|
||||
return mapEntry != null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final class KeySet extends AbstractSet<K> {
|
||||
|
||||
@Override
|
||||
public Iterator<K> iterator() {
|
||||
return new MapIterator<K>() {
|
||||
@Override
|
||||
public K next() {
|
||||
if (mapEntry == null) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
K key = mapEntry.getKey();
|
||||
mapEntry = null;
|
||||
return key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if (mapEntry == null) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
map.remove(mapEntry.getKey());
|
||||
mapEntry = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
return AbstractCacheMap.this.containsKey(o);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean remove(Object o) {
|
||||
return AbstractCacheMap.this.remove(o) != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return AbstractCacheMap.this.size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
AbstractCacheMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final class Values extends AbstractCollection<V> {
|
||||
|
||||
@Override
|
||||
public Iterator<V> iterator() {
|
||||
return new MapIterator<V>() {
|
||||
@Override
|
||||
public V next() {
|
||||
if (mapEntry == null) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
V value = readValue(mapEntry.getValue());
|
||||
mapEntry = null;
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if (mapEntry == null) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
map.remove(mapEntry.getKey(), mapEntry.getValue());
|
||||
mapEntry = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
return AbstractCacheMap.this.containsValue(o);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return AbstractCacheMap.this.size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
AbstractCacheMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
|
||||
|
||||
public final Iterator<Map.Entry<K,V>> iterator() {
|
||||
return new MapIterator<Map.Entry<K,V>>() {
|
||||
@Override
|
||||
public Map.Entry<K,V> next() {
|
||||
if (mapEntry == null) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
SimpleEntry<K, V> result = new SimpleEntry<K, V>(mapEntry.getKey(), readValue(mapEntry.getValue()));
|
||||
mapEntry = null;
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
if (mapEntry == null) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
map.remove(mapEntry.getKey(), mapEntry.getValue());
|
||||
mapEntry = null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public final boolean contains(Object o) {
|
||||
if (!(o instanceof Map.Entry))
|
||||
return false;
|
||||
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
|
||||
Object key = e.getKey();
|
||||
V value = get(key);
|
||||
return value != null && value.equals(e);
|
||||
}
|
||||
|
||||
public final boolean remove(Object o) {
|
||||
if (o instanceof Map.Entry) {
|
||||
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
|
||||
Object key = e.getKey();
|
||||
Object value = e.getValue();
|
||||
return AbstractCacheMap.this.map.remove(key, value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public final int size() {
|
||||
return AbstractCacheMap.this.size();
|
||||
}
|
||||
|
||||
public final void clear() {
|
||||
AbstractCacheMap.this.clear();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,32 @@
|
||||
/**
|
||||
* 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.misc;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public interface Cache<K, V> extends Map<K, V> {
|
||||
|
||||
V put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit);
|
||||
|
||||
}
|
||||
@ -0,0 +1,157 @@
|
||||
/**
|
||||
* 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.misc;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentNavigableMap;
|
||||
import java.util.concurrent.ConcurrentSkipListMap;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
|
||||
/**
|
||||
* LFU (least frequently used) cache.
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public class LFUCacheMap<K, V> extends AbstractCacheMap<K, V> {
|
||||
|
||||
public static class MapKey implements Comparable<MapKey> {
|
||||
|
||||
private Long accessCount;
|
||||
private LFUCachedValue cachedValue;
|
||||
|
||||
public MapKey(Long accessCount, LFUCachedValue cachedValue) {
|
||||
super();
|
||||
this.accessCount = accessCount;
|
||||
this.cachedValue = cachedValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(MapKey o) {
|
||||
int compare = accessCount.compareTo(o.accessCount);
|
||||
if (compare == 0) {
|
||||
return cachedValue.id.compareTo(o.cachedValue.id);
|
||||
}
|
||||
return compare;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "MapKey [accessCount=" + accessCount + "]";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static class LFUCachedValue extends CachedValue {
|
||||
|
||||
Long id;
|
||||
long accessCount;
|
||||
|
||||
public LFUCachedValue(long id, Object key, Object value, long ttl, long maxIdleTime) {
|
||||
super(key, value, ttl, maxIdleTime);
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public void addAccessCount(long value) {
|
||||
accessCount += value;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private final AtomicLong idGenerator = new AtomicLong();
|
||||
private final ConcurrentNavigableMap<MapKey, LFUCachedValue> accessMap = new ConcurrentSkipListMap<MapKey, LFUCachedValue>();
|
||||
|
||||
public LFUCacheMap(int size, long timeToLiveInMillis, long maxIdleInMillis) {
|
||||
super(size, timeToLiveInMillis, maxIdleInMillis);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected CachedValue create(K key, V value, long ttl, long maxIdleTime) {
|
||||
return new LFUCachedValue(idGenerator.incrementAndGet(), key, value, ttl, maxIdleTime);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueCreate(CachedValue value) {
|
||||
MapKey key = toKey((LFUCachedValue)value);
|
||||
accessMap.put(key, (LFUCachedValue)value);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueRead(CachedValue value) {
|
||||
addAccessCount((LFUCachedValue)value, 1);
|
||||
}
|
||||
|
||||
private MapKey toKey(LFUCachedValue value) {
|
||||
return new MapKey(value.accessCount, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueRemove(CachedValue value) {
|
||||
synchronized (value) {
|
||||
MapKey key = toKey((LFUCachedValue)value);
|
||||
accessMap.remove(key);
|
||||
}
|
||||
}
|
||||
|
||||
private void addAccessCount(LFUCachedValue value, long count) {
|
||||
synchronized (value) {
|
||||
if (count < 0 && value.accessCount == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
MapKey key = toKey(value);
|
||||
if (accessMap.remove(key) == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (count < 0) {
|
||||
count = -Math.min(value.accessCount, -count);
|
||||
}
|
||||
value.addAccessCount(count);
|
||||
|
||||
key = toKey(value);
|
||||
accessMap.put(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onMapFull() {
|
||||
Map.Entry<MapKey, LFUCachedValue> entry = accessMap.pollFirstEntry();
|
||||
if (entry == null) {
|
||||
return;
|
||||
}
|
||||
map.remove(entry.getValue().getKey(), entry.getValue());
|
||||
|
||||
if (entry.getValue().accessCount == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO optimize
|
||||
// decrease all values
|
||||
for (LFUCachedValue value : accessMap.values()) {
|
||||
addAccessCount(value, -entry.getValue().accessCount);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
accessMap.clear();
|
||||
super.clear();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,69 @@
|
||||
/**
|
||||
* 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.misc;
|
||||
|
||||
import java.util.Queue;
|
||||
import java.util.concurrent.ConcurrentLinkedQueue;
|
||||
|
||||
/**
|
||||
* LRU (least recently used) cache.
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public class LRUCacheMap<K, V> extends AbstractCacheMap<K, V> {
|
||||
|
||||
private final Queue<CachedValue> queue = new ConcurrentLinkedQueue<CachedValue>();
|
||||
|
||||
public LRUCacheMap(int size, long timeToLiveInMillis, long maxIdleInMillis) {
|
||||
super(size, timeToLiveInMillis, maxIdleInMillis);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueCreate(CachedValue value) {
|
||||
queue.add(value);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueRemove(CachedValue value) {
|
||||
queue.remove(value);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onValueRead(CachedValue value) {
|
||||
// move value to tail of queue
|
||||
if (queue.remove(value)) {
|
||||
queue.add(value);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onMapFull() {
|
||||
CachedValue value = queue.poll();
|
||||
if (value != null) {
|
||||
map.remove(value.getKey(), value);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
queue.clear();
|
||||
super.clear();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,35 @@
|
||||
/**
|
||||
* 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.misc;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nikita Koksharov
|
||||
*
|
||||
* @param <K>
|
||||
* @param <V>
|
||||
*/
|
||||
public class NoneCacheMap<K, V> extends AbstractCacheMap<K, V> {
|
||||
|
||||
public NoneCacheMap(long timeToLiveInMillis, long maxIdleInMillis) {
|
||||
super(0, timeToLiveInMillis, maxIdleInMillis);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onMapFull() {
|
||||
}
|
||||
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue