K
- the key type of map.V
- the value type of map.public class MapProxyImpl<K,V> extends AbstractDistributedObject<MapService> implements EventJournalReader<EventJournalMapEvent<K,V>>
IMap
interface.Modifier and Type | Field and Description |
---|---|
protected LocalMapStatsImpl |
localMapStats |
protected LockProxySupport |
lockSupport |
protected MapConfig |
mapConfig |
protected MapServiceContext |
mapServiceContext |
protected String |
name |
protected static String |
NULL_AGGREGATOR_IS_NOT_ALLOWED |
protected static String |
NULL_KEY_IS_NOT_ALLOWED |
protected static String |
NULL_KEYS_ARE_NOT_ALLOWED |
protected static String |
NULL_LISTENER_IS_NOT_ALLOWED |
protected static String |
NULL_PREDICATE_IS_NOT_ALLOWED |
protected static String |
NULL_PROJECTION_IS_NOT_ALLOWED |
protected static String |
NULL_VALUE_IS_NOT_ALLOWED |
protected MapOperationProvider |
operationProvider |
protected OperationService |
operationService |
protected IPartitionService |
partitionService |
protected PartitioningStrategy |
partitionStrategy |
protected SerializationService |
serializationService |
protected boolean |
statisticsEnabled |
protected Address |
thisAddress |
PARTITIONING_STRATEGY
Constructor and Description |
---|
MapProxyImpl(String name,
MapService mapService,
NodeEngine nodeEngine,
MapConfig mapConfig) |
Modifier and Type | Method and Description |
---|---|
String |
addEntryListener(EntryListener listener,
boolean includeValue)
Adds an entry listener for this map.
|
String |
addEntryListener(EntryListener listener,
K key,
boolean includeValue)
Adds the specified entry listener for the specified key.
|
String |
addEntryListener(EntryListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds an continuous entry listener for this map.
|
String |
addEntryListener(EntryListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds an continuous entry listener for this map.
|
String |
addEntryListener(MapListener listener,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
K key,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addEntryListener(MapListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds a
MapListener for this map. |
protected String |
addEntryListenerInternal(Object listener,
Data key,
boolean includeValue) |
protected String |
addEntryListenerInternal(Object listener,
Predicate predicate,
Data key,
boolean includeValue) |
void |
addIndex(String attribute,
boolean ordered)
Adds an index to this map for the specified entries so
that queries can run faster.
|
String |
addInterceptor(MapInterceptor interceptor)
Adds an interceptor for this map.
|
String |
addLocalEntryListener(EntryListener listener)
Adds a local entry listener for this map.
|
String |
addLocalEntryListener(EntryListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds a local entry listener for this map.
|
String |
addLocalEntryListener(EntryListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds a local entry listener for this map.
|
String |
addLocalEntryListener(MapListener listener)
Adds a
MapListener for this map. |
String |
addLocalEntryListener(MapListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Adds a
MapListener for this map. |
String |
addLocalEntryListener(MapListener listener,
Predicate<K,V> predicate,
K key,
boolean includeValue)
Adds a local entry listener for this map.
|
String |
addLocalEntryListenerInternal(Object listener) |
String |
addLocalEntryListenerInternal(Object listener,
Predicate predicate,
Data key,
boolean includeValue) |
String |
addMapInterceptorInternal(MapInterceptor interceptor) |
String |
addPartitionLostListener(MapPartitionLostListener listener)
Adds a MapPartitionLostListener.
|
protected String |
addPartitionLostListenerInternal(MapPartitionLostListener listener) |
<R> R |
aggregate(Aggregator<Map.Entry<K,V>,R> aggregator)
Applies the aggregation logic on all map entries and returns the result
|
<R> R |
aggregate(Aggregator<Map.Entry<K,V>,R> aggregator,
Predicate<K,V> predicate)
Applies the aggregation logic on map entries filtered with the Predicated and returns the result
|
<SuppliedValue,Result> |
aggregate(Supplier<K,V,SuppliedValue> supplier,
Aggregation<K,SuppliedValue,Result> aggregation)
Executes a predefined aggregation on the maps data set.
|
<SuppliedValue,Result> |
aggregate(Supplier<K,V,SuppliedValue> supplier,
Aggregation<K,SuppliedValue,Result> aggregation,
JobTracker jobTracker)
Executes a predefined aggregation on the maps data set.
|
void |
clear()
Clears the map and deletes the items from the backing map store.
|
void |
clearInternal() |
boolean |
containsKey(Object key)
Returns
true if this map contains an entry for the specified
key. |
protected boolean |
containsKeyInternal(Object key) |
boolean |
containsValue(Object value) |
boolean |
containsValueInternal(Data dataValue) |
protected Iterable<Data> |
convertToData(Iterable<K> keys) |
void |
delete(Object key)
Removes the mapping for the key from this map if it is present.
|
protected void |
deleteInternal(Object key) |
Set<Map.Entry<K,V>> |
entrySet()
Returns a
Set clone of the mappings contained in this map. |
Set<Map.Entry<K,V>> |
entrySet(Predicate predicate)
Queries the map based on the specified predicate and returns the matching entries.
|
boolean |
evict(Object key)
Evicts the specified key from this map.
|
void |
evictAll()
Evicts all keys from this map except the locked ones.
|
protected void |
evictAllInternal() |
protected boolean |
evictInternal(Object key)
Evicts a key from a map.
|
Map<K,Object> |
executeOnEntries(EntryProcessor entryProcessor)
Applies the user defined
EntryProcessor to the all entries in the map. |
Map<K,Object> |
executeOnEntries(EntryProcessor entryProcessor,
Predicate predicate)
Applies the user defined
EntryProcessor to the entries in the map which satisfy provided predicate. |
void |
executeOnEntriesInternal(EntryProcessor entryProcessor,
Predicate predicate,
List<Data> result)
|
Object |
executeOnKey(K key,
EntryProcessor entryProcessor)
Applies the user defined
EntryProcessor to the entry mapped by the key . |
Data |
executeOnKeyInternal(Object key,
EntryProcessor entryProcessor) |
InternalCompletableFuture<Object> |
executeOnKeyInternal(Object key,
EntryProcessor entryProcessor,
ExecutionCallback<Object> callback) |
Map<K,Object> |
executeOnKeys(Set<K> keys,
EntryProcessor entryProcessor)
Applies the user defined
EntryProcessor to the entries mapped by the collection of keys. |
protected <T extends Result> |
executeQueryInternal(Predicate predicate,
Aggregator aggregator,
Projection projection,
IterationType iterationType,
Target target) |
protected <T extends Result> |
executeQueryInternal(Predicate predicate,
IterationType iterationType,
Target target) |
protected void |
finalizePutAll(Map<?,?> map) |
void |
flush()
If this map has a MapStore, this method flushes
all the local dirty entries.
|
void |
forceUnlock(K key)
Releases the lock for the specified key regardless of the lock owner.
|
V |
get(Object key)
Returns the value for the specified key, or
null if this map does not contain this key. |
Map<K,V> |
getAll(Set<K> keys)
Returns the entries for the given keys.
|
protected void |
getAllInternal(Set<K> keys,
List<Data> dataKeys,
List<Object> resultingKeyValuePairs) |
ICompletableFuture<V> |
getAsync(K key)
Asynchronously gets the given key.
|
protected InternalCompletableFuture<Data> |
getAsyncInternal(Object key) |
EntryView<K,V> |
getEntryView(K key)
Returns the
EntryView for the specified key. |
protected EntryView |
getEntryViewInternal(Data key) |
protected Object |
getInternal(Object key) |
LocalMapStats |
getLocalMapStats()
Returns LocalMapStats for this map.
|
protected QueryEngine |
getMapQueryEngine() |
String |
getName()
Returns the unique name for this DistributedObject.
|
MapOperationProvider |
getOperationProvider() |
PartitioningStrategy |
getPartitionStrategy() |
QueryCache<K,V> |
getQueryCache(String name)
Returns corresponding
QueryCache instance for the supplied name or null. |
QueryCache<K,V> |
getQueryCache(String name,
MapListener listener,
Predicate<K,V> predicate,
boolean includeValue)
Creates an always up to date snapshot of this
IMap according to the supplied parameters. |
QueryCache<K,V> |
getQueryCache(String name,
Predicate<K,V> predicate,
boolean includeValue)
Creates an always up to date snapshot of this
IMap according to the supplied parameters. |
String |
getServiceName()
Returns the service name for this object.
|
int |
getTotalBackupCount() |
protected void |
handleHazelcastInstanceAwareParams(Object... objects) |
void |
initialize() |
protected Object |
invoke(Operation operation,
int partitionId) |
protected void |
invokePutAllOperationFactory(long size,
int[] partitions,
MapEntries[] entries) |
boolean |
isEmpty()
Returns true if this map contains no entries.
|
boolean |
isLocked(K key)
Checks the lock for the specified key.
|
protected boolean |
isMapStoreEnabled() |
Iterator<Map.Entry<K,V>> |
iterator(int fetchSize,
int partitionId,
boolean prefetchValues)
Returns an iterator for iterating entries in the
partitionId . |
<R> Iterator<R> |
iterator(int fetchSize,
int partitionId,
Projection<Map.Entry<K,V>,R> projection,
Predicate<K,V> predicate)
Returns an iterator for iterating the result of the projection on entries in the
partitionId which
satisfy the predicate . |
Set<K> |
keySet()
Returns a set clone of the keys contained in this map.
|
Set<K> |
keySet(Predicate predicate)
Queries the map based on the specified predicate and
returns the keys of matching entries.
|
void |
loadAll(boolean replaceExistingValues)
Loads all keys into the store.
|
void |
loadAll(Set<K> keys,
boolean replaceExistingValues)
Loads the given keys.
|
protected void |
loadAllInternal(boolean replaceExistingValues) |
protected void |
loadInternal(Set<K> keys,
Iterable<Data> dataKeys,
boolean replaceExistingValues)
Maps keys to corresponding partitions and sends operations to them.
|
Set<K> |
localKeySet()
Returns the locally owned set of keys.
|
Set<K> |
localKeySet(Predicate predicate)
Returns the keys of matching locally owned entries.
|
void |
lock(K key)
Acquires the lock for the specified key.
|
void |
lock(Object key,
long leaseTime,
TimeUnit timeUnit)
Acquires the lock for the specified key for the specified lease time.
|
protected boolean |
preDestroy() |
<R> Collection<R> |
project(Projection<Map.Entry<K,V>,R> projection)
Applies the projection logic on all map entries and returns the result
|
<R> Collection<R> |
project(Projection<Map.Entry<K,V>,R> projection,
Predicate<K,V> predicate)
Applies the projection logic on map entries filtered with the Predicated and returns the result
|
V |
put(K key,
V value)
Associates the specified value with the specified key in this map.
|
V |
put(K key,
V value,
long ttl,
TimeUnit timeunit)
Puts an entry into this map with a given TTL (time to live) value.
|
V |
put(K key,
V value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Puts an entry into this map with a given TTL (time to live) value and max idle time value.
|
void |
putAll(Map<? extends K,? extends V> map) |
protected void |
putAllInternal(Map<?,?> map)
This method will group all puts per partition and send a
PutAllPartitionAwareOperationFactory per member. |
ICompletableFuture<V> |
putAsync(K key,
V value)
Asynchronously puts the given key and value.
|
ICompletableFuture<V> |
putAsync(K key,
V value,
long ttl,
TimeUnit timeunit)
Asynchronously puts the given key and value into this map with a given TTL (time to live) value.
|
ICompletableFuture<V> |
putAsync(K key,
V value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Asynchronously puts the given key and value into this map with a given TTL (time to live) value and max idle time value.
|
protected InternalCompletableFuture<Data> |
putAsyncInternal(Object key,
Data value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit) |
V |
putIfAbsent(K key,
V value)
If the specified key is not already associated
with a value, associate it with the given value.
|
V |
putIfAbsent(K key,
V value,
long ttl,
TimeUnit timeunit)
Puts an entry into this map with a given TTL (time to live) value,
if the specified key is not already associated with a value.
|
V |
putIfAbsent(K key,
V value,
long ttl,
TimeUnit timeunit,
long maxIdle,
TimeUnit maxIdleUnit)
Puts an entry into this map with a given TTL (time to live) value and max idle time value.
|
protected Data |
putIfAbsentInternal(Object key,
Data value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit) |
protected Data |
putInternal(Object key,
Data value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit) |
void |
putTransient(K key,
V value,
long ttl,
TimeUnit timeunit)
Same as
#put(K, V, long, java.util.concurrent.TimeUnit)
except that the map store, if defined, will not be called to
load/store/persist the entry. |
void |
putTransient(K key,
V value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Same as
#put(K, V, long, java.util.concurrent.TimeUnit)
except that the map store, if defined, will not be called to
load/store/persist the entry. |
protected void |
putTransientInternal(Object key,
Data value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit) |
<T> ICompletableFuture<ReadResultSet<T>> |
readFromEventJournal(long startSequence,
int minSize,
int maxSize,
int partitionId,
Predicate<? super EventJournalMapEvent<K,V>> predicate,
Function<? super EventJournalMapEvent<K,V>,? extends T> projection)
Reads from the event journal.
|
V |
remove(Object key)
Removes the mapping for a key from this map if it is present.
|
boolean |
remove(Object key,
Object value)
Removes the entry for a key only if currently mapped to a given value.
|
void |
removeAll(Predicate<K,V> predicate)
Removes all entries which match with the supplied predicate.
|
protected void |
removeAllInternal(Predicate predicate) |
ICompletableFuture<V> |
removeAsync(K key)
Asynchronously removes the given key, returning an
ICompletableFuture on which
the caller can provide an ExecutionCallback to be invoked upon remove operation
completion or block waiting for the operation to complete with Future.get() . |
protected InternalCompletableFuture<Data> |
removeAsyncInternal(Object key) |
boolean |
removeEntryListener(String id)
Removes the specified entry listener.
|
protected boolean |
removeEntryListenerInternal(String id) |
void |
removeInterceptor(String id)
Removes the given interceptor for this map, so it will not intercept operations anymore.
|
protected Data |
removeInternal(Object key) |
protected boolean |
removeInternal(Object key,
Data value) |
void |
removeMapInterceptorInternal(String id) |
boolean |
removePartitionLostListener(String id)
Removes the specified map partition lost listener.
|
protected boolean |
removePartitionLostListenerInternal(String id) |
V |
replace(K key,
V value)
Replaces the entry for a key only if it is currently mapped to some value.
|
boolean |
replace(K key,
V oldValue,
V newValue)
Replaces the entry for a key only if currently mapped to a given value.
|
protected Data |
replaceInternal(Object key,
Data value) |
protected boolean |
replaceInternal(Object key,
Data expect,
Data update) |
void |
set(K key,
V value)
Puts an entry into this map without returning the old value
(which is more efficient than
put() ). |
void |
set(K key,
V value,
long ttl,
TimeUnit ttlUnit)
Puts an entry into this map with a given TTL (time to live) value,
without returning the old value (which is more efficient than
put() ). |
void |
set(K key,
V value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Puts an entry into this map with a given TTL (time to live) value and max idle time value.
|
ICompletableFuture<Void> |
setAsync(K key,
V value)
Asynchronously puts the given key and value.
|
ICompletableFuture<Void> |
setAsync(K key,
V value,
long ttl,
TimeUnit timeunit)
Asynchronously puts an entry into this map with a given TTL (time to live) value,
without returning the old value (which is more efficient than
put() ). |
ICompletableFuture<Void> |
setAsync(K key,
V value,
long ttl,
TimeUnit ttlUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Asynchronously puts an entry into this map with a given TTL (time to live) value and max idle time value.
|
protected InternalCompletableFuture<Data> |
setAsyncInternal(Object key,
Data value,
long ttl,
TimeUnit timeunit,
long maxIdle,
TimeUnit maxIdleUnit) |
protected void |
setInternal(Object key,
Data value,
long ttl,
TimeUnit timeunit,
long maxIdle,
TimeUnit maxIdleUnit) |
void |
setOperationProvider(MapOperationProvider operationProvider) |
boolean |
setTtl(K key,
long ttl,
TimeUnit timeunit)
Updates TTL (time to live) value of the entry specified by
key with a new TTL value. |
protected boolean |
setTtlInternal(Object key,
long ttl,
TimeUnit timeUnit) |
int |
size()
Returns the number of entries in this map.
|
ICompletableFuture |
submitToKey(K key,
EntryProcessor entryProcessor)
Applies the user defined
EntryProcessor to the entry mapped by the key . |
void |
submitToKey(K key,
EntryProcessor entryProcessor,
ExecutionCallback callback)
Applies the user defined
EntryProcessor to the entry mapped by the key with
specified ExecutionCallback to listen event status and returns immediately. |
ICompletableFuture<Map<K,Object>> |
submitToKeys(Set<K> keys,
EntryProcessor entryProcessor)
Async version of
executeOnKeys(java.util.Set<K>, com.hazelcast.map.EntryProcessor) . |
ICompletableFuture<Map<K,Object>> |
submitToKeysInternal(Set<K> keys,
Set<Data> dataKeys,
EntryProcessor entryProcessor) |
ICompletableFuture<EventJournalInitialSubscriberState> |
subscribeToEventJournal(int partitionId)
Subscribe to the event journal for this reader and a specific partition ID.
|
protected Data |
toData(Object object,
PartitioningStrategy partitioningStrategy) |
protected void |
toDataCollectionWithNonNullKeyValidation(Set<K> keys,
Collection<Data> dataKeys) |
protected Data |
toDataWithStrategy(Object object) |
protected <T> T |
toObject(Object object) |
String |
toString() |
boolean |
tryLock(K key)
Tries to acquire the lock for the specified key.
|
boolean |
tryLock(K key,
long time,
TimeUnit timeunit)
Tries to acquire the lock for the specified key.
|
boolean |
tryLock(K key,
long time,
TimeUnit timeunit,
long leaseTime,
TimeUnit leaseTimeUnit)
Tries to acquire the lock for the specified key for the specified lease time.
|
boolean |
tryPut(K key,
V value,
long timeout,
TimeUnit timeunit)
Tries to put the given key and value into this map within a specified
timeout value.
|
protected boolean |
tryPutInternal(Object key,
Data value,
long timeout,
TimeUnit timeunit) |
boolean |
tryRemove(K key,
long timeout,
TimeUnit timeunit)
Tries to remove the entry with the given key from this map
within the specified timeout value.
|
protected boolean |
tryRemoveInternal(Object key,
long timeout,
TimeUnit timeunit) |
void |
unlock(K key)
Releases the lock for the specified key.
|
Collection<V> |
values()
Returns a collection clone of the values contained in this map.
|
Collection<V> |
values(Predicate predicate)
Queries the map based on the specified predicate and returns the values of matching entries.
|
void |
waitUntilLoaded() |
destroy, equals, getDistributedObjectName, getNameAsPartitionAwareData, getNodeEngine, getOperationService, getPartitionId, getPartitionKey, getService, hashCode, invalidate, invokeOnPartition, isClusterVersionEqualTo, isClusterVersionGreaterOrEqual, isClusterVersionGreaterThan, isClusterVersionLessOrEqual, isClusterVersionLessThan, isClusterVersionUnknown, isClusterVersionUnknownOrGreaterOrEqual, isClusterVersionUnknownOrGreaterThan, isClusterVersionUnknownOrLessOrEqual, isClusterVersionUnknownOrLessThan, postDestroy, throwNotActiveException, toData
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll
destroy, getPartitionKey
protected static final String NULL_KEY_IS_NOT_ALLOWED
protected static final String NULL_KEYS_ARE_NOT_ALLOWED
protected static final String NULL_VALUE_IS_NOT_ALLOWED
protected static final String NULL_PREDICATE_IS_NOT_ALLOWED
protected static final String NULL_LISTENER_IS_NOT_ALLOWED
protected static final String NULL_AGGREGATOR_IS_NOT_ALLOWED
protected static final String NULL_PROJECTION_IS_NOT_ALLOWED
protected final String name
protected final LocalMapStatsImpl localMapStats
protected final LockProxySupport lockSupport
protected final PartitioningStrategy partitionStrategy
protected final MapServiceContext mapServiceContext
protected final IPartitionService partitionService
protected final Address thisAddress
protected final OperationService operationService
protected final SerializationService serializationService
protected final boolean statisticsEnabled
protected final MapConfig mapConfig
protected MapOperationProvider operationProvider
public MapProxyImpl(String name, MapService mapService, NodeEngine nodeEngine, MapConfig mapConfig)
public V get(Object key)
IMap
null
if this map does not contain this key.
Warning 1:
This method returns a clone of the original value, so modifying the returned value does not change the actual value in the map. You should put the modified value back to make changes visible to all nodes.
V value = map.get(key); value.updateSomeProperty(); map.put(key, value);
Warning 2:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If value with key
is not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
public V put(K key, V value)
IMap
Warning 1:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 2:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Note:
Use IMap.set(Object, Object)
if you don't need the return value, it's slightly more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public V put(K key, V value, long ttl, TimeUnit timeunit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Note:
Use IMap.set(Object, Object, long, TimeUnit)
if you don't need the return value, it's slightly more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
put
in interface BaseMap<K,V>
put
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLpublic V put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Note:
Use IMap.set(Object, Object, long, TimeUnit)
if you don't need the return value, it's slightly more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
put
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)ttlUnit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-Idlepublic boolean tryPut(K key, V value, long timeout, TimeUnit timeunit)
IMap
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public V putIfAbsent(K key, V value)
IMap
if (!map.containsKey(key)) return map.put(key, value); else return map.get(key);except that the action is performed atomically.
Note:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Also, this method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putIfAbsent
in interface BaseMap<K,V>
putIfAbsent
in interface IMap<K,V>
putIfAbsent
in interface ConcurrentMap<K,V>
putIfAbsent
in interface Map<K,V>
key
- The specified key.value
- The value to associate with the key when there is no previous value.public V putIfAbsent(K key, V value, long ttl, TimeUnit timeunit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putIfAbsent
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLpublic V putIfAbsent(K key, V value, long ttl, TimeUnit timeunit, long maxIdle, TimeUnit maxIdleUnit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Warning 3:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putIfAbsent
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-Idlepublic void putTransient(K key, V value, long ttl, TimeUnit timeunit)
IMap
#put(K, V, long, java.util.concurrent.TimeUnit)
except that the map store, if defined, will not be called to
load/store/persist the entry.
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to next closest second value.
putTransient
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLpublic void putTransient(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
IMap
#put(K, V, long, java.util.concurrent.TimeUnit)
except that the map store, if defined, will not be called to
load/store/persist the entry.
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to next closest second value.
putTransient
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)ttlUnit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-Idlepublic boolean replace(K key, V oldValue, V newValue)
IMap
if (map.containsKey(key) && map.get(key).equals(oldValue)) { map.put(key, newValue); return true; } else return false;except that the action is performed atomically.
Warning 1:
This method uses hashCode
and equals
of the
binary form of the key
, not the actual implementations of
hashCode
and equals
defined in the key
's
class.
Warning 2:
This method may return false
even if the operation succeeds.
Background: If the partition owner for given key goes down after successful value replace, but before the executing node
retrieved the invocation result response, then the operation is retried. The invocation
retry fails because the value is already updated and the result of such replace call
returns false
. Hazelcast doesn't guarantee exactly once invocation.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
replace
in interface BaseMap<K,V>
replace
in interface IMap<K,V>
replace
in interface ConcurrentMap<K,V>
replace
in interface Map<K,V>
key
- The specified key.oldValue
- Replace the key value if it is the old value.newValue
- The new value to replace the old value.true
if the value was replaced.public V replace(K key, V value)
IMap
if (map.containsKey(key)) { return map.put(key, value); } else return null;except that the action is performed atomically.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
replace
in interface BaseMap<K,V>
replace
in interface IMap<K,V>
replace
in interface ConcurrentMap<K,V>
replace
in interface Map<K,V>
key
- The specified key.value
- The value to replace the previous value.key
, or null
if there was no mapping for key
.public void set(K key, V value)
IMap
put()
).
Warning 1:
This method breaks the contract of EntryListener. When an entry is updated by set(), it fires an EntryEvent with a null oldValue.
Warning 2:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public void set(K key, V value, long ttl, TimeUnit ttlUnit)
IMap
put()
).
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public void set(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
IMap
put()
).
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
set
in interface IMap<K,V>
key
- key of the entryvalue
- value of the entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)ttlUnit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-Idlepublic V remove(Object key)
IMap
If you don't need the previously mapped value for the removed key, prefer to use
IMap.delete(java.lang.Object)
and avoid the cost of serialization and network transfer.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is removed from the memory, MapStore.delete(Object)
is
called to remove the value from the map store. Exceptions thrown
by delete fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
remove
in interface BaseMap<K,V>
remove
in interface IMap<K,V>
remove
in interface Map<K,V>
key
- Remove the mapping for this key.key
, or null
if there was no mapping for key
.IMap.delete(Object)
public boolean remove(Object key, Object value)
IMap
if (map.containsKey(key) && map.get(key).equals(value)) { map.remove(key); return true; } else return false;except that the action is performed atomically.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is removed from the memory, MapStore.delete(Object)
is
called to remove the value from the map store. Exceptions thrown
by delete fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
remove
in interface BaseMap<K,V>
remove
in interface IMap<K,V>
remove
in interface ConcurrentMap<K,V>
remove
in interface Map<K,V>
key
- The specified key.value
- Remove the key if it has this value.true
if the value was removed.public void removeAll(Predicate<K,V> predicate)
IMap
If this map has index, matching entries will be found via index search, otherwise they will be found by full-scan.
Note that calling this method also removes all entries from caller's Near Cache.
Interactions with the map store
If write-through persistence mode is configured, before a value is
removed from the memory, MapStore.delete(Object)
is called to
remove the value from the map store. Exceptions thrown by delete fail
the operation and are propagated to the caller.
If write-behind persistence mode is configured with write-coalescing
turned off, ReachedMaxSizeException
may be
thrown if the write-behind queue has reached its per-node maximum
capacity.
public void delete(Object key)
IMap
Unlike IMap.remove(Object)
, this operation does not return
the removed value, which avoids the serialization and network transfer cost of the
returned value. If the removed value will not be used, this operation
is preferred over the remove operation for better performance.
The map will not contain a mapping for the specified key once the call returns.
Warning:
This method breaks the contract of EntryListener. When an entry is removed by delete(), it fires an EntryEvent with a null oldValue.
Also, a listener with predicates will have null values, so only keys can be queried via predicates.
Interactions with the map store
If write-through persistence mode is configured, before the value
is removed from the the memory, MapStore.delete(Object)
is called to remove the value from the map store. Exceptions
thrown by delete fail the operation and are propagated to the
caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public boolean containsKey(Object key)
IMap
true
if this map contains an entry for the specified
key.
Warning:
This method uses hashCode
and equals
of the binary form of the key
,
not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If key
is not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
containsKey
in interface BaseMap<K,V>
containsKey
in interface IMap<K,V>
containsKey
in interface Map<K,V>
key
- The specified key.true
if this map contains an entry for the specified key.public boolean containsValue(Object value)
IMap
containsValue
in interface IMap<K,V>
containsValue
in interface Map<K,V>
public void lock(K key)
IMap
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
You get a lock whether the value is present in the map or not. Other
threads (possibly on other systems) would block on their invoke of
lock()
until the non-existent key is unlocked. If the lock
holder introduces the key to the map, the put()
operation
is not blocked. If a thread not holding a lock on the non-existent key
tries to introduce the key while a lock exists on the non-existent key,
the put()
operation blocks until it is unlocked.
Scope of the lock is this map only. Acquired lock is only for the key in this map.
Locks are re-entrant so if the key is locked N times then it should be unlocked N times before another thread can acquire it.
There is no lock timeout on this method. Locks will be held infinitely.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
public void lock(Object key, long leaseTime, TimeUnit timeUnit)
IMap
After lease time, the lock will be released.
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
Scope of the lock is this map only. Acquired lock is only for the key in this map.
Locks are re-entrant, so if the key is locked N times then it should be unlocked N times before another thread can acquire it.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
public void unlock(K key)
IMap
If the current thread is the holder of this lock, then the hold
count is decremented. If the hold count is zero, then the lock
is released. If the current thread is not the holder of this
lock, then IllegalMonitorStateException
is thrown.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
public boolean tryRemove(K key, long timeout, TimeUnit timeunit)
IMap
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If write-through persistence mode is configured, before the value
is removed from the the memory, MapStore.delete(Object)
is called to remove the value from the map store. Exceptions
thrown by delete fail the operation and are propagated to the
caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public ICompletableFuture<V> getAsync(K key)
IMap
ICompletableFuture future = map.getAsync(key); // do some other stuff, when ready get the result. Object value = future.get();
Future.get()
will block until the actual map.get() completes.
If the application requires timely response,
then Future.get(long, TimeUnit)
can be used.
try { ICompletableFuture future = map.getAsync(key); Object value = future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }Additionally, the client can schedule an
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via
ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
// assuming an IMap<String, String>
ICompletableFuture<String> future = map.getAsync("a");
future.andThen(new ExecutionCallback<String>() {
public void onResponse(String response) {
// do something with value in response
}
public void onFailure(Throwable t) {
// handle failure
}
});
ExecutionException is never thrown.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If value with key
is not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
getAsync
in interface IMap<K,V>
getAsync
in interface LegacyAsyncMap<K,V>
key
- the key of the map entryICompletableFuture
public boolean isLocked(K key)
IMap
If the lock is acquired then returns true, else returns false.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
public ICompletableFuture<V> putAsync(K key, V value)
IMap
ICompletableFuture future = map.putAsync(key, value); // do some other stuff, when ready get the result. Object oldValue = future.get();ICompletableFuture.get() will block until the actual map.put() completes. If the application requires a timely response, then you can use Future.get(timeout, timeunit).
try { ICompletableFuture future = map.putAsync(key, newValue); Object oldValue = future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }Additionally, the client can schedule an
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
// assuming an IMap<String, String>
ICompletableFuture<String> future = map.putAsync("a", "b");
future.andThen(new ExecutionCallback<String>() {
public void onResponse(String response) {
// do something with the old value returned by put operation
}
public void onFailure(Throwable t) {
// handle failure
}
});
ExecutionException is never thrown.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Note:
Use IMap.setAsync(Object, Object)
if you don't need the return value, it's slightly more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putAsync
in interface IMap<K,V>
putAsync
in interface LegacyAsyncMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryICompletableFuture
,
IMap.setAsync(Object, Object)
public ICompletableFuture<V> putAsync(K key, V value, long ttl, TimeUnit timeunit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
ICompletableFuture future = map.putAsync(key, value, ttl, timeunit); // do some other stuff, when ready get the result Object oldValue = future.get();ICompletableFuture.get() will block until the actual map.put() completes. If your application requires a timely response, then you can use Future.get(timeout, timeunit).
try { ICompletableFuture future = map.putAsync(key, newValue, ttl, timeunit); Object oldValue = future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }The client can schedule an
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
// assuming an IMap<String, String>
ICompletableFuture<String> future = map.putAsync("a", "b", 5, TimeUnit.MINUTES);
future.andThen(new ExecutionCallback<String>() {
public void onResponse(String response) {
// do something with old value returned by put operation
}
public void onFailure(Throwable t) {
// handle failure
}
});
ExecutionException is never thrown.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Note:
Use IMap.setAsync(Object, Object, long, TimeUnit)
if you don't need the return value, it's slightly
more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putAsync
in interface IMap<K,V>
putAsync
in interface LegacyAsyncMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLICompletableFuture
,
IMap.setAsync(Object, Object, long, TimeUnit)
public ICompletableFuture<V> putAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
IMap
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
ICompletableFuture future = map.putAsync(key, value, ttl, timeunit); // do some other stuff, when ready get the result Object oldValue = future.get();ICompletableFuture.get() will block until the actual map.put() completes. If your application requires a timely response, then you can use Future.get(timeout, timeunit).
try { ICompletableFuture future = map.putAsync(key, newValue, ttl, timeunit); Object oldValue = future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }The client can schedule an
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
// assuming an IMap<String, String>
ICompletableFuture<String> future = map.putAsync("a", "b", 5, TimeUnit.MINUTES);
future.andThen(new ExecutionCallback<String>() {
public void onResponse(String response) {
// do something with old value returned by put operation
}
public void onFailure(Throwable t) {
// handle failure
}
});
ExecutionException is never thrown.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Note:
Use IMap.setAsync(Object, Object, long, TimeUnit)
if you don't need the return value, it's slightly
more efficient.
Interactions with the map store
If no value is found with key
in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map. Exceptions thrown by load fail
the operation and are propagated to the caller.
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
putAsync
in interface IMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)ttlUnit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-IdleICompletableFuture
,
IMap.setAsync(Object, Object, long, TimeUnit)
public ICompletableFuture<Void> setAsync(K key, V value)
IMap
ICompletableFuture<Void> future = map.setAsync(key, value);
// do some other stuff, when ready wait for completion
future.get();
ICompletableFuture.get() will block until the actual map.set() operation completes.
If your application requires a timely response,
then you can use ICompletableFuture.get(timeout, timeunit).
try {
ICompletableFuture<Void> future = map.setAsync(key, newValue);
future.get(40, TimeUnit.MILLISECOND);
} catch (TimeoutException t) {
// time wasn't enough
}
You can also schedule an ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
ICompletableFuture<Void> future = map.setAsync("a", "b");
future.andThen(new ExecutionCallback<String>() {
public void onResponse(Void response) {
// Set operation was completed
}
public void onFailure(Throwable t) {
// handle failure
}
});
ExecutionException is never thrown.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
setAsync
in interface IMap<K,V>
setAsync
in interface LegacyAsyncMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryExecutionCallback
to be invoked upon completionICompletableFuture
public ICompletableFuture<Void> setAsync(K key, V value, long ttl, TimeUnit timeunit)
IMap
put()
).
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
ICompletableFuture<Void> future = map.setAsync(key, value, ttl, timeunit); // do some other stuff, when you want to make sure set operation is complete: future.get();ICompletableFuture.get() will block until the actual map set operation completes. If your application requires a timely response, then you can use
Future.get(long, TimeUnit)
.
try { ICompletableFutureYou can also schedule anfuture = map.setAsync(key, newValue, ttl, timeunit); future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
ICompletableFuture<Void> future = map.setAsync("a", "b", 5, TimeUnit.MINUTES); future.andThen(new ExecutionCallback<String>() { public void onResponse(Void response) { // Set operation was completed } public void onFailure(Throwable t) { // handle failure } });ExecutionException is never thrown.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller..
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
setAsync
in interface IMap<K,V>
setAsync
in interface LegacyAsyncMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLExecutionCallback
to be invoked upon set operation completionICompletableFuture
public ICompletableFuture<Void> setAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
IMap
put()
).
The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
ICompletableFuture<Void> future = map.setAsync(key, value, ttl, timeunit); // do some other stuff, when you want to make sure set operation is complete: future.get();ICompletableFuture.get() will block until the actual map set operation completes. If your application requires a timely response, then you can use
Future.get(long, TimeUnit)
.
try { ICompletableFutureYou can also schedule anfuture = map.setAsync(key, newValue, ttl, timeunit); future.get(40, TimeUnit.MILLISECOND); } catch (TimeoutException t) { // time wasn't enough }
ExecutionCallback
to be invoked upon
completion of the ICompletableFuture
via ICompletableFuture.andThen(ExecutionCallback)
or
ICompletableFuture.andThen(ExecutionCallback, Executor)
:
ICompletableFuture<Void> future = map.setAsync("a", "b", 5, TimeUnit.MINUTES); future.andThen(new ExecutionCallback<String>() { public void onResponse(Void response) { // Set operation was completed } public void onFailure(Throwable t) { // handle failure } });ExecutionException is never thrown.
Warning 1:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Warning 2:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
Interactions with the map store
If write-through persistence mode is configured, before the value
is stored in memory, MapStore.store(Object, Object)
is
called to write the value into the map store. Exceptions thrown
by the store fail the operation and are propagated to the caller..
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
setAsync
in interface IMap<K,V>
key
- the key of the map entryvalue
- the new value of the map entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)ttlUnit
- time unit for the TTLmaxIdle
- maximum time for this entry to stay idle in the map.
(0 means infinite, negative means map config default)maxIdleUnit
- time unit for the Max-IdleExecutionCallback
to be invoked upon set operation completionICompletableFuture
public ICompletableFuture<V> removeAsync(K key)
IMap
ICompletableFuture
on which
the caller can provide an ExecutionCallback
to be invoked upon remove operation
completion or block waiting for the operation to complete with Future.get()
.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
Interactions with the map store
If write-through persistence mode is configured, before the value
is removed from the the memory, MapStore.delete(Object)
is called to remove the value from the map store. Exceptions
thrown by delete fail the operation and are propagated to the
caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
removeAsync
in interface IMap<K,V>
removeAsync
in interface LegacyAsyncMap<K,V>
key
- The key of the map entry to removeICompletableFuture
from which the value removed from the map can be retrievedICompletableFuture
public Map<K,V> getAll(Set<K> keys)
IMap
Warning 1:
The returned map is NOT backed by the original map, so changes to the original map are NOT reflected in the returned map, and vice-versa.
Warning 2:
This method uses hashCode
and equals
of the
binary form of the keys
, not the actual implementations
of hashCode
and equals
defined in the
key
's class.
Interactions with the map store
If any keys are not found in memory,
MapLoader.loadAll(java.util.Collection)
is called with
the missing keys. Exceptions thrown by loadAll fail the operation
and are propagated to the caller.
public boolean setTtl(K key, long ttl, TimeUnit timeunit)
IMap
key
with a new TTL value.
New TTL value is valid starting from the time this operation is invoked, not since the time the entry was created.
If the entry does not exist or is already expired, this call has no effect.
The entry will expire and get evicted after the TTL. If the TTL is 0,
then the entry lives forever. If the TTL is negative, then the TTL
from the map configuration will be used (default: forever).
If there is no entry with key key
or is already expired, this call makes no changes to entries stored in
this map.
Warning:
Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
setTtl
in interface IMap<K,V>
key
- the key of the map entryttl
- maximum time for this entry to stay in the map (0 means infinite, negative means map config default)timeunit
- time unit for the TTLtrue
if the entry exists and its ttl value is changed, false
otherwisepublic void putAll(Map<? extends K,? extends V> map)
IMap
No atomicity guarantees are given. It could be that in case of failure some of the key/value-pairs get written, while others are not.
Interactions with the map store
For each element not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map, which may come at a significant
performance cost. Exceptions thrown by load fail the operation
and are propagated to the caller. The elements which were added
before the exception was thrown will remain in the map, the rest
will not be added.
If write-through persistence mode is configured,
MapStore.store(Object, Object)
is invoked for each element
before the element is added in memory, which may come at a
significant performance cost. Exceptions thrown by store fail the
operation and are propagated to the caller. The elements which
were added before the exception was thrown will remain in the map,
the rest will not be added.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
public boolean tryLock(K key)
IMap
If the lock is not available then the current thread doesn't wait and returns false immediately.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
public boolean tryLock(K key, long time, TimeUnit timeunit) throws InterruptedException
IMap
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
tryLock
in interface IMap<K,V>
key
- key to lock in this maptime
- maximum time to wait for the locktimeunit
- time unit of the time
argumenttrue
if the lock was acquired, false
if the waiting time elapsed before the lock was acquiredInterruptedException
public boolean tryLock(K key, long time, TimeUnit timeunit, long leaseTime, TimeUnit leaseTimeUnit) throws InterruptedException
IMap
After lease time, the lock will be released.
If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
tryLock
in interface IMap<K,V>
key
- key to lock in this maptime
- maximum time to wait for the locktimeunit
- time unit of the time
argumentleaseTime
- time to wait before releasing the lockleaseTimeUnit
- unit of time to specify lease timetrue
if the lock was acquired, false
if the waiting time elapsed before the lock was acquiredInterruptedException
public void forceUnlock(K key)
IMap
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
forceUnlock
in interface IMap<K,V>
key
- the key to lockpublic String addInterceptor(MapInterceptor interceptor)
IMap
Added interceptor will intercept operations and execute user defined methods. They will cancel operations if the user defined method throws an exception.
addInterceptor
in interface IMap<K,V>
interceptor
- map interceptorpublic void removeInterceptor(String id)
IMap
removeInterceptor
in interface IMap<K,V>
id
- registration ID of the map interceptorpublic String addLocalEntryListener(MapListener listener)
IMap
MapListener
for this map. To receive an event, you should
implement a corresponding MapListener
sub-interface for that event.
Note that entries in distributed map are partitioned across
the cluster members; each member owns and manages the some portion of the
entries. Owned entries are called local entries. This
listener will be listening for the events of local entries. Let's say
your cluster has member1 and member2. On member2 you added a local listener and from
member1, you call map.put(key2, value2)
.
If the key2 is owned by member2 then the local listener will be
notified for the add/update event. Also note that entries can migrate to
other nodes for load balancing and/or membership change.
addLocalEntryListener
in interface IMap<K,V>
listener
- MapListener
for this mapIMap.localKeySet()
,
MapListener
public String addLocalEntryListener(EntryListener listener)
IMap
Note that entries in distributed map are partitioned across
the cluster members; each member owns and manages the some portion of the
entries. Owned entries are called local entries. This
listener will be listening for the events of local entries. Let's say
your cluster has member1 and member2. On member2 you added a local listener and from
member1, you call map.put(key2, value2)
.
If the key2 is owned by member2 then the local listener will be
notified for the add/update event. Also note that entries can migrate to
other nodes for load balancing and/or membership change.
addLocalEntryListener
in interface IMap<K,V>
listener
- entry listenerIMap.localKeySet()
public String addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)
IMap
MapListener
for this map.
To receive an event, you should implement a corresponding MapListener
sub-interface for that event.
The listener will get notified for map events filtered by the given predicate.
addLocalEntryListener
in interface IMap<K,V>
listener
- MapListener
for this mappredicate
- predicate for filtering entriesincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)
IMap
The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
addLocalEntryListener
in interface IMap<K,V>
listener
- entry listenerpredicate
- predicate for filtering entriesincludeValue
- true
if EntryEvent
should contain the valuepublic String addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
IMap
The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
addLocalEntryListener
in interface IMap<K,V>
listener
- MapListener
for this mappredicate
- predicate for filtering entrieskey
- key to listen forincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
IMap
The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
addLocalEntryListener
in interface IMap<K,V>
listener
- entry listenerpredicate
- predicate for filtering entrieskey
- key to listen foincludeValue
- true
if EntryEvent
should contain the valuepublic String addEntryListener(MapListener listener, boolean includeValue)
IMap
MapListener
for this map.
To receive an event, you should implement a corresponding MapListener
sub-interface for that event.
addEntryListener
in interface IMap<K,V>
listener
- MapListener
for this mapincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addEntryListener(EntryListener listener, boolean includeValue)
IMap
The listener will get notified for all map add/remove/update/evict events.
addEntryListener
in interface IMap<K,V>
listener
- the added entry listener for this mapincludeValue
- true
if EntryEvent
should contain the valuepublic String addEntryListener(MapListener listener, K key, boolean includeValue)
IMap
MapListener
for this map. To receive an event, you should
implement a corresponding MapListener
sub-interface for that event.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
addEntryListener
in interface IMap<K,V>
listener
- MapListener
for this mapkey
- key to listen forincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addEntryListener(EntryListener listener, K key, boolean includeValue)
IMap
The listener will get notified for all add/remove/update/evict events of the specified key only.
Warning:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
addEntryListener
in interface IMap<K,V>
listener
- specified entry listenerkey
- key to listen forincludeValue
- true
if EntryEvent
should contain the valuepublic String addEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
IMap
MapListener
for this map.
To receive an event, you should implement a corresponding MapListener
sub-interface for that event.
addEntryListener
in interface IMap<K,V>
listener
- the continuous MapListener
for this mappredicate
- predicate for filtering entrieskey
- key to listen forincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)
IMap
The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
addEntryListener
in interface IMap<K,V>
listener
- the continuous entry listener for this mappredicate
- predicate for filtering entrieskey
- key to listen forincludeValue
- true
if EntryEvent
should contain the valuepublic String addEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)
IMap
MapListener
for this map.
To receive an event, you should implement a corresponding MapListener
sub-interface for that event.
addEntryListener
in interface IMap<K,V>
listener
- the added continuous MapListener
for this mappredicate
- predicate for filtering entriesincludeValue
- true
if EntryEvent
should contain the valueMapListener
public String addEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)
IMap
The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
addEntryListener
in interface IMap<K,V>
listener
- the added continuous entry listener for this mappredicate
- predicate for filtering entriesincludeValue
- true
if EntryEvent
should contain the valuepublic boolean removeEntryListener(String id)
IMap
Returns silently if there is no such listener added before.
removeEntryListener
in interface IMap<K,V>
id
- ID of registered listenerpublic String addPartitionLostListener(MapPartitionLostListener listener)
IMap
The addPartitionLostListener returns a register ID. This ID is needed to remove the MapPartitionLostListener using the
IMap.removePartitionLostListener(String)
method.
There is no check for duplicate registrations, so if you register the listener twice, it will get events twice.
Warning 1:
Please see PartitionLostListener
for weaknesses.
Warning 2:
Listeners registered from HazelcastClient may miss some of the map partition lost events due to design limitations.
addPartitionLostListener
in interface IMap<K,V>
listener
- the added MapPartitionLostListenerIMap.removePartitionLostListener(String)
,
PartitionLostListener
public boolean removePartitionLostListener(String id)
IMap
Returns silently if there is no such listener was added before.
removePartitionLostListener
in interface IMap<K,V>
id
- ID of registered listenerpublic EntryView<K,V> getEntryView(K key)
IMap
EntryView
for the specified key.
Warning 1:
This method returns a clone of original mapping, modifying the returned value does not change the actual value in the map. One should put modified value back to make changes visible to all nodes.
Warning 2:
This method uses hashCode
and equals
of the binary form of
the key
, not the actual implementations of hashCode
and equals
defined in the key
's class.
getEntryView
in interface IMap<K,V>
key
- the key of the entryEntryView
of the specified keyEntryView
public boolean evict(Object key)
IMap
If a MapStore
is defined for this map, then the entry is
not deleted from the underlying MapStore
, evict only
removes the entry from the memory. Use IMap.delete(Object)
or
IMap.remove(Object)
if MapStore.delete(Object)
needs
to be called.
Warning:
This method uses hashCode
and equals
of the
binary form of the key
, not the actual implementations of
hashCode
and equals
defined in the key
's
class.
evict
in interface IMap<K,V>
key
- the specified key to evict from this maptrue
if the key is evicted, false
otherwiseIMap.delete(Object)
,
IMap.remove(Object)
public void evictAll()
IMap
If a MapStore
is defined for this map, deleteAll is
not called by this method. If you do want to
MapStore.deleteAll(Collection)
to be called use the
IMap.clear()
method.
The EVICT_ALL event is fired for any registered listeners.
See MapEvictedListener.mapEvicted(MapEvent)
.
evictAll
in interface IMap<K,V>
IMap.clear()
public void loadAll(boolean replaceExistingValues)
IMap
Interactions with the map store
Calls MapLoader.loadAllKeys()
and with the loaded keys
calls MapLoader.loadAll(java.util.Collection)
on each
partition. Exceptions thrown by loadAllKeys() or loadAll() are
not propagated to the caller.
loadAll
in interface IMap<K,V>
replaceExistingValues
- when true
, existing values
in the Map will be replaced by those
loaded from the MapLoader
IMap.loadAll(boolean)
public void loadAll(Set<K> keys, boolean replaceExistingValues)
IMap
Interactions with the map store
Calls MapLoader.loadAll(java.util.Collection)
on the
partitions storing the values with the keys. Exceptions thrown by
loadAll() are not propagated to the caller.
public void clear()
IMap
The MAP_CLEARED event is fired for any registered listeners.
See MapClearedListener.mapCleared(MapEvent)
.
To clear the map without removing the items from the map store,
use IMap.evictAll()
.
Interactions with the map store
Calls MapStore.deleteAll(Collection)
on each partition
with the keys that the given partition stores. Exceptions thrown
by deleteAll() are not propagated to the caller.
public Set<K> keySet()
IMap
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
public Set<K> keySet(Predicate predicate)
IMap
Specified predicate runs on all members in parallel.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
public Set<Map.Entry<K,V>> entrySet()
IMap
Set
clone of the mappings contained in this map.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
public Set<Map.Entry<K,V>> entrySet(Predicate predicate)
IMap
Specified predicate runs on all members in parallel.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
entrySet
in interface IMap<K,V>
predicate
- specified query criteriaGroupProperty.QUERY_RESULT_SIZE_LIMIT
public Collection<V> values()
IMap
Warning:
The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
public Collection<V> values(Predicate predicate)
IMap
Specified predicate runs on all members in parallel.
Warning:
The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
public Set<K> localKeySet()
IMap
Each key in this map is owned and managed by a specific member in the cluster.
Note that ownership of these keys might change over time so that key ownerships can be almost evenly distributed in the cluster.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
localKeySet
in interface IMap<K,V>
GroupProperty.QUERY_RESULT_SIZE_LIMIT
public Set<K> localKeySet(Predicate predicate)
IMap
Each key in this map is owned and managed by a specific member in the cluster.
Note that ownership of these keys might change over time so that key ownerships can be almost evenly distributed in the cluster.
Warning:
The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
This method is always executed by a distributed query,
so it may throw a QueryResultSizeExceededException
if GroupProperty.QUERY_RESULT_SIZE_LIMIT
is configured.
localKeySet
in interface IMap<K,V>
predicate
- specified query criteriaGroupProperty.QUERY_RESULT_SIZE_LIMIT
public Object executeOnKey(K key, EntryProcessor entryProcessor)
IMap
EntryProcessor
to the entry mapped by the key
.
Returns the object which is the result of the EntryProcessor#process(Entry)
method.
The EntryProcessor
may implement the Offloadable
and ReadOnly
interfaces.
If the EntryProcessor implements the Offloadable
interface, the processing will be offloaded to the given
ExecutorService, allowing unblocking of the partition-thread, which means that other partition-operations
may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict.
In this case the threading looks as follows:
If the EntryProcessor implements only ReadOnly without implementing Offloadable, the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
If the EntryProcessor implements ReadOnly and modifies the entry it is processing, an UnsupportedOperationException will be thrown.
Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor, for example the "delta", so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
See IMap.submitToKey(Object, EntryProcessor)
for an async version of this method.
Interactions with the map store
If value with key
is not found in memory,
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map.
If the entryProcessor updates the entry and write-through
persistence mode is configured, before the value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If the entryProcessor updates the entry's value to null value and
write-through persistence mode is configured, before the value is
removed from the memory, MapStore.delete(Object)
is
called to delete the value from the map store.
Any exceptions thrown by the map store fail the operation and are propagated to the caller.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
executeOnKey
in interface IMap<K,V>
EntryProcessor#process(Entry)
Offloadable
,
ReadOnly
public Map<K,Object> executeOnKeys(Set<K> keys, EntryProcessor entryProcessor)
IMap
EntryProcessor
to the entries mapped by the collection of keys.
The operation is not lock-aware. The EntryProcessor
will process the entries no matter if the keys are
locked or not. For more details check Entry Processing section on IMap
documentation.
Interactions with the map store
For each entry not found in memory MapLoader.load(Object)
is invoked to load the value from the map store backing the map.
If write-through persistence mode is configured, for each entry
updated by the entryProcessor, before the updated value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If write-through persistence mode is configured, for each entry
updated to null value, before the value is removed from the
memory, MapStore.delete(Object)
is called to delete the
value from the map store.
Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
If write-behind persistence mode is
configured with write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
Keep the state of entryProcessor
small, it will be serialized and one copy will be sent to each member.
Additionally, the backup
processor will also be serialized once for each affected partition and
sent to each backup. For example, in this usage the entire additions
map will be duplicated once for each member and once for each
partition and backup:
HashMap additions = ...;
iMap.executeOnKeys(map.keySet(), new AbstractEntryProcessor<Integer, Integer>() {
public Object process(Entry<Integer, Integer> entry) {
Integer updateBy = additions.get(entry.getKey());
entry.setValue(entry.getValue() + updateBy);
return null;
}
});
executeOnKeys
in interface IMap<K,V>
keys
- The keys to execute the entry processor on. Can be empty, in
that case it's a local no-opEntryProcessor#process(Entry)
public ICompletableFuture<Map<K,Object>> submitToKeys(Set<K> keys, EntryProcessor entryProcessor)
executeOnKeys(java.util.Set<K>, com.hazelcast.map.EntryProcessor)
.public void submitToKey(K key, EntryProcessor entryProcessor, ExecutionCallback callback)
IMap
EntryProcessor
to the entry mapped by the key
with
specified ExecutionCallback
to listen event status and returns immediately.
The EntryProcessor
may implement the Offloadable
and ReadOnly
interfaces.
If the EntryProcessor implements the Offloadable
interface the processing will be offloaded to the given
ExecutorService allowing unblocking of the partition-thread, which means that other partition-operations
may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict.
In this case the threading looks as follows:
If the EntryProcessor implements only ReadOnly without implementing Offloadable the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
If the EntryProcessor implements ReadOnly and modifies the entry it is processing an UnsupportedOperationException will be thrown.
Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor - for example the "delta" so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
See IMap.executeOnKey(Object, EntryProcessor)
for sync version of this method.
Interactions with the map store
If value with key
is not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map.
If the entryProcessor updates the entry and write-through
persistence mode is configured, before the value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If the entryProcessor updates the entry's value to null value and
write-through persistence mode is configured, before the value is
removed from the memory, MapStore.delete(Object)
is
called to delete the value from the map store.
Any exception thrown by the map store fail the operation and are
propagated to the provided callback via ExecutionCallback.onFailure(Throwable)
.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
submitToKey
in interface IMap<K,V>
key
- key to be processedentryProcessor
- processor to process the keycallback
- to listen whether operation is finished or notOffloadable
,
ReadOnly
public ICompletableFuture submitToKey(K key, EntryProcessor entryProcessor)
IMap
EntryProcessor
to the entry mapped by the key
.
Returns immediately with a ICompletableFuture
representing that task.
EntryProcessor is not cancellable, so calling ICompletableFuture.cancel() method won't cancel the operation of EntryProcessor.
The EntryProcessor may implement the Offloadable and ReadOnly interfaces.
If the EntryProcessor implements the Offloadable interface the processing will be offloaded to the given ExecutorService allowing unblocking the partition-thread, which means that other partition-operations may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict. In this case the threading looks as follows:
If the EntryProcessor implements only ReadOnly without implementing Offloadable the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
If the EntryProcessor implements ReadOnly and modifies the entry it is processing a UnsupportedOperationException will be thrown.
Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor - for example the "delta" so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
See IMap.executeOnKey(Object, EntryProcessor)
for sync version of this method.
Interactions with the map store
If value with key
is not found in memory
MapLoader.load(Object)
is invoked to load the value from
the map store backing the map.
If the entryProcessor updates the entry and write-through
persistence mode is configured, before the value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If the entryProcessor updates the entry's value to null value and
write-through persistence mode is configured, before the value is
removed from the memory, MapStore.delete(Object)
is
called to delete the value from the map store.
Any exception thrown by the map store fail the operation and are
propagated to the provided callback via ExecutionCallback.onFailure(Throwable)
.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
submitToKey
in interface IMap<K,V>
submitToKey
in interface LegacyAsyncMap<K,V>
key
- key to be processedentryProcessor
- processor to process the keyOffloadable
,
ReadOnly
,
ICompletableFuture
public Map<K,Object> executeOnEntries(EntryProcessor entryProcessor)
IMap
EntryProcessor
to the all entries in the map.
Returns the results mapped by each key in the map.
The operation is not lock-aware. The EntryProcessor
will process the entries no matter if the keys are
locked or not. For more details check Entry Processing section on IMap
documentation.
Interactions with the map store
For each entry not found in memory MapLoader.load(Object)
is invoked to load the value from the map store backing the map.
If write-through persistence mode is configured, for each entry
updated by the entryProcessor, before the updated value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If write-through persistence mode is configured, for each entry
updated to null value, before the value is removed from the
memory, MapStore.delete(Object)
is called to delete the
value from the map store.
Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
executeOnEntries
in interface IMap<K,V>
public Map<K,Object> executeOnEntries(EntryProcessor entryProcessor, Predicate predicate)
IMap
EntryProcessor
to the entries in the map which satisfy provided predicate.
Returns the results mapped by each key in the map.
The operation is not lock-aware. The EntryProcessor
will process the entries no matter if the keys are
locked or not. For more details check Entry Processing section on IMap
documentation.
Interactions with the map store
For each entry not found in memory MapLoader.load(Object)
is invoked to load the value from the map store backing the map.
If write-through persistence mode is configured, for each entry
updated by the entryProcessor, before the updated value is stored
in memory, MapStore.store(Object, Object)
is called to
write the value into the map store.
If write-through persistence mode is configured, for each entry
updated to null value, before the value is removed from the
memory, MapStore.delete(Object)
is called to delete the
value from the map store.
Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
If write-behind persistence mode is configured with
write-coalescing turned off,
ReachedMaxSizeException
may be thrown
if the write-behind queue has reached its per-node maximum
capacity.
executeOnEntries
in interface IMap<K,V>
public <R> R aggregate(Aggregator<Map.Entry<K,V>,R> aggregator)
IMap
Fast-Aggregations are the successor of the Map-Reduce Aggregators. They are equivalent to the Map-Reduce Aggregators in most of the use-cases, but instead of running on the Map-Reduce engine they run on the Query infrastructure. Their performance is tens to hundreds times better due to the fact that they run in parallel for each partition and are highly optimized for speed and low memory consumption.
public <R> R aggregate(Aggregator<Map.Entry<K,V>,R> aggregator, Predicate<K,V> predicate)
IMap
Fast-Aggregations are the successor of the Map-Reduce Aggregators. They are equivalent to the Map-Reduce Aggregators in most of the use-cases, but instead of running on the Map-Reduce engine they run on the Query infrastructure. Their performance is tens to hundreds times better due to the fact that they run in parallel for each partition and are highly optimized for speed and low memory consumption.
public <R> Collection<R> project(Projection<Map.Entry<K,V>,R> projection)
IMap
public <R> Collection<R> project(Projection<Map.Entry<K,V>,R> projection, Predicate<K,V> predicate)
IMap
public <SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation)
IMap
Supplier
is used to either select or to select and extract a (sub-)value. A predefined set of aggregations can be found in
Aggregations
.aggregate
in interface IMap<K,V>
SuppliedValue
- the final type emitted from the supplierResult
- the resulting aggregation value typesupplier
- the supplier to select and / or extract a (sub-)value from the mapaggregation
- the aggregation that is being executed against the mappublic <SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation, JobTracker jobTracker)
IMap
The Supplier
is used to either select or to select and extract a (sub-)value.
A predefined set of aggregations can be found in Aggregations
.
aggregate
in interface IMap<K,V>
SuppliedValue
- the final type emitted from the supplierResult
- the resulting aggregation value typesupplier
- the supplier to select and / or extract a (sub-)value from the mapaggregation
- the aggregation that is being executed against the mapjobTracker
- the JobTracker
instance to execute the aggregationprotected Object invoke(Operation operation, int partitionId) throws Throwable
Throwable
public Iterator<Map.Entry<K,V>> iterator(int fetchSize, int partitionId, boolean prefetchValues)
partitionId
. If prefetchValues
is
true
, values will be sent along with the keys and no additional data will be fetched when
iterating. If false
, only keys will be sent and values will be fetched when calling Map.Entry.getValue()
lazily.
The entries are not fetched one-by-one but in batches.
You may control the size of the batch by changing the fetchSize
parameter.
A too small fetchSize
can affect performance since more data will have to be sent to and from the partition owner.
A too high fetchSize
means that more data will be sent which can block other operations from being sent,
including internal operations.
The underlying implementation may send more values in one batch than fetchSize
if it needs to get to
a "safepoint" to resume iteration later.
NOTE
Iterating the map should be done only when the IMap
is not being
mutated and the cluster is stable (there are no migrations or membership changes).
In other cases, the iterator may not return some entries or may return an entry twice.
fetchSize
- the size of the batches which will be sent when iterating the datapartitionId
- the partition ID which is being iteratedprefetchValues
- whether to send values along with keys (if true
) or
to fetch them lazily when iterating (if false
)public <R> Iterator<R> iterator(int fetchSize, int partitionId, Projection<Map.Entry<K,V>,R> projection, Predicate<K,V> predicate)
partitionId
which
satisfy the predicate
.
The values are not fetched one-by-one but rather in batches.
You may control the size of the batch by changing the fetchSize
parameter.
A too small fetchSize
can affect performance since more data will have to be sent to and from the partition owner.
A too high fetchSize
means that more data will be sent which can block other operations from being sent,
including internal operations.
The underlying implementation may send more values in one batch than fetchSize
if it needs to get to
a "safepoint" to later resume iteration.
Predicates of type PagingPredicate
are not supported.
NOTE
Iterating the map should be done only when the IMap
is not being
mutated and the cluster is stable (there are no migrations or membership changes).
In other cases, the iterator may not return some entries or may return an entry twice.
R
- the return typefetchSize
- the size of the batches which will be sent when iterating the datapartitionId
- the partition ID which is being iteratedprojection
- the projection to apply before returning the value. null
value is not allowedpredicate
- the predicate which the entries must match. null
value is not allowedIllegalArgumentException
- if the predicate is of type PagingPredicate
public ICompletableFuture<EventJournalInitialSubscriberState> subscribeToEventJournal(int partitionId)
EventJournalReader
subscribeToEventJournal
in interface EventJournalReader<EventJournalMapEvent<K,V>>
partitionId
- the partition ID of the entries to which we are subscribingpublic <T> ICompletableFuture<ReadResultSet<T>> readFromEventJournal(long startSequence, int minSize, int maxSize, int partitionId, Predicate<? super EventJournalMapEvent<K,V>> predicate, Function<? super EventJournalMapEvent<K,V>,? extends T> projection)
UnsupportedOperationException
if the cluster version is lower than 3.9 or there is no event journal configured for this data structure.
NOTE:
Configuring evictions may cause unexpected results when reading from the event journal and
there are cluster changes (a backup replica is promoted into a partition owner). See
MapEventJournal
or
CacheEventJournal
for more details.
This implementation will skip cloning of the predicate and projection for performance reasons. Because of this, the results of the projection and predicate should not depend on any state that will be lost while cloning. If you wish to get rid of user state, you may clone the predicate and projection and keep them cached for all calls to this method to avoid the overhead of cloning.
readFromEventJournal
in interface EventJournalReader<EventJournalMapEvent<K,V>>
T
- the return type of the projection. It is equal to the journal event type
if the projection is null
or it is the identity projectionstartSequence
- the sequence of the first item to readmaxSize
- the maximum number of items to readpartitionId
- the partition ID of the entries in the journalpredicate
- the predicate which the events must pass to be included in the response.
May be null
in which case all events pass the predicateprojection
- the projection which is applied to the events before returning.
May be null
in which case the event is returned without being projectedpublic String toString()
toString
in class AbstractDistributedObject<MapService>
public QueryCache<K,V> getQueryCache(String name)
IMap
QueryCache
instance for the supplied name
or null.
If there is a previously created QueryCache
with the supplied name
or if a declarative
configuration exists for the supplied name
this method returns or creates the instance respectively,
otherwise returns null.
getQueryCache
in interface IMap<K,V>
name
- the name of QueryCache
QueryCache
instance or null if there is no corresponding QueryCacheConfig
QueryCache
public QueryCache<K,V> getQueryCache(String name, Predicate<K,V> predicate, boolean includeValue)
IMap
IMap
according to the supplied parameters.
If there is a previously created QueryCache
with the supplied name
, this method returns that
QueryCache
and ignores predicate
and includeValue
parameters. Otherwise it creates and returns
a new QueryCache
instance.
Also note that if there exists a QueryCacheConfig
for the supplied
name
, predicate
and includeValue
parameters will overwrite corresponding ones
in QueryCacheConfig
.
getQueryCache
in interface IMap<K,V>
name
- the name of QueryCache
predicate
- the predicate for filtering entriesincludeValue
- true
if this QueryCache
is allowed to cache values of entries, otherwise false
QueryCache
instance with the supplied name
QueryCache
public QueryCache<K,V> getQueryCache(String name, MapListener listener, Predicate<K,V> predicate, boolean includeValue)
IMap
IMap
according to the supplied parameters.
If there is a previously created QueryCache
with the supplied name
, this method returns that
QueryCache
and ignores listener
, predicate
and includeValue
parameters.
Otherwise it creates and returns a new QueryCache
instance.
Also note that if there exists a QueryCacheConfig
for the supplied
name
, listener
,predicate
and includeValue
parameters will overwrite corresponding ones
in QueryCacheConfig
.
getQueryCache
in interface IMap<K,V>
name
- the name of QueryCache
listener
- the MapListener
which will be used to listen this QueryCache
predicate
- the predicate for filtering entriesincludeValue
- true
if this QueryCache
is allowed to cache values of entries, otherwise false
QueryCache
instance with the supplied name
QueryCache
public final String getName()
DistributedObject
DistributedObjectUtil.getName(DistributedObject)
because this might be also a PrefixedDistributedObject
.getName
in interface DistributedObject
public final String getServiceName()
DistributedObject
getServiceName
in interface DistributedObject
getServiceName
in class AbstractDistributedObject<MapService>
public void initialize()
initialize
in interface InitializingObject
public PartitioningStrategy getPartitionStrategy()
public MapOperationProvider getOperationProvider()
public void setOperationProvider(MapOperationProvider operationProvider)
public int getTotalBackupCount()
protected QueryEngine getMapQueryEngine()
protected boolean isMapStoreEnabled()
protected InternalCompletableFuture<Data> getAsyncInternal(Object key)
protected Data putInternal(Object key, Data value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
protected boolean tryPutInternal(Object key, Data value, long timeout, TimeUnit timeunit)
protected Data putIfAbsentInternal(Object key, Data value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
protected void putTransientInternal(Object key, Data value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
protected InternalCompletableFuture<Data> putAsyncInternal(Object key, Data value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)
protected InternalCompletableFuture<Data> setAsyncInternal(Object key, Data value, long ttl, TimeUnit timeunit, long maxIdle, TimeUnit maxIdleUnit)
protected void setInternal(Object key, Data value, long ttl, TimeUnit timeunit, long maxIdle, TimeUnit maxIdleUnit)
protected boolean evictInternal(Object key)
key
- the key to evicttrue
if eviction was successful, false
otherwiseprotected void evictAllInternal()
protected void loadAllInternal(boolean replaceExistingValues)
protected void loadInternal(Set<K> keys, Iterable<Data> dataKeys, boolean replaceExistingValues)
protected void deleteInternal(Object key)
protected void removeAllInternal(Predicate predicate)
protected InternalCompletableFuture<Data> removeAsyncInternal(Object key)
protected boolean containsKeyInternal(Object key)
public void waitUntilLoaded()
public int size()
BaseMap
public boolean containsValueInternal(Data dataValue)
public boolean isEmpty()
BaseMap
protected void getAllInternal(Set<K> keys, List<Data> dataKeys, List<Object> resultingKeyValuePairs)
protected void putAllInternal(Map<?,?> map)
PutAllPartitionAwareOperationFactory
per member.
If there are e.g. five keys for a single member, there will only be a single remote invocation instead of having five remote invocations.
There is also an optional support for batching to send smaller packages.
Takes care about null
checks for keys and values.
protected void invokePutAllOperationFactory(long size, int[] partitions, MapEntries[] entries) throws Exception
Exception
protected void finalizePutAll(Map<?,?> map)
public void flush()
IMap
Interactions with the map store
Calls MapStore.storeAll(Map)
and/or
MapStore.deleteAll(Collection)
with elements marked dirty.
Please note that this method has effect only if write-behind
persistence mode is configured. If the persistence mode is
write-through calling this method has no practical effect, but an
operation is executed on all partitions wasting resources.
public void clearInternal()
public String addMapInterceptorInternal(MapInterceptor interceptor)
public void removeMapInterceptorInternal(String id)
public String addLocalEntryListenerInternal(Object listener, Predicate predicate, Data key, boolean includeValue)
protected String addEntryListenerInternal(Object listener, Data key, boolean includeValue)
protected String addEntryListenerInternal(Object listener, Predicate predicate, Data key, boolean includeValue)
protected boolean removeEntryListenerInternal(String id)
protected String addPartitionLostListenerInternal(MapPartitionLostListener listener)
protected boolean removePartitionLostListenerInternal(String id)
public Data executeOnKeyInternal(Object key, EntryProcessor entryProcessor)
public ICompletableFuture<Map<K,Object>> submitToKeysInternal(Set<K> keys, Set<Data> dataKeys, EntryProcessor entryProcessor)
public InternalCompletableFuture<Object> executeOnKeyInternal(Object key, EntryProcessor entryProcessor, ExecutionCallback<Object> callback)
public void executeOnEntriesInternal(EntryProcessor entryProcessor, Predicate predicate, List<Data> result)
protected <T> T toObject(Object object)
protected Data toData(Object object, PartitioningStrategy partitioningStrategy)
public void addIndex(String attribute, boolean ordered)
IMap
Let's say your map values are Employee objects.
public class Employee implements Serializable { private boolean active = false; private int age; private String name = null; // other fields // getters setter }If you are querying your values mostly based on age and active then you should consider indexing these fields.
IMap imap = Hazelcast.getMap("employees"); imap.addIndex("age", true); // ordered, since we have ranged queries for this field imap.addIndex("active", false); // not ordered, because boolean field cannot have rangeIndex attribute should either have a getter method or be public. You should also make sure to add the indexes before adding entries to this map.
Time to Index
Indexing time is executed in parallel on each partition by operation threads. The Map is not blocked during this operation.
The time taken in proportional to the size of the Map and the number Members.
Searches while indexes are being built
Until the index finishes being created, any searches for the attribute will use a full Map scan, thus avoiding using a partially built index and returning incorrect results.
public LocalMapStats getLocalMapStats()
IMap
LocalMapStats are the statistics for the local portion of this distributed map and contains information such as ownedEntryCount backupEntryCount, lastUpdateTime, lockedEntryCount.
Since this stats are only for the local portion of this map, if you need the cluster-wide MapStats then you need to get the LocalMapStats from all members of the cluster and combine them.
It's guaranteed that the returned LocalMapStats
instance contains
an up-to-date statistics. But over the time some parts of the returned
instance may become stale while others may be updated. To obtain a fresh
up-to-date instance invoke the method one more time.
getLocalMapStats
in interface IMap<K,V>
protected boolean preDestroy()
preDestroy
in class AbstractDistributedObject<MapService>
protected void toDataCollectionWithNonNullKeyValidation(Set<K> keys, Collection<Data> dataKeys)
protected <T extends Result> T executeQueryInternal(Predicate predicate, IterationType iterationType, Target target)
protected <T extends Result> T executeQueryInternal(Predicate predicate, Aggregator aggregator, Projection projection, IterationType iterationType, Target target)
protected void handleHazelcastInstanceAwareParams(Object... objects)
Copyright © 2019 Hazelcast, Inc.. All Rights Reserved.