Interface IgniteCache<K,V>
- 
- Type Parameters:
- K- Cache key type.
- V- Cache value type.
 - All Superinterfaces:
- AutoCloseable,- javax.cache.Cache<K,V>,- Closeable,- IgniteAsyncSupport,- Iterable<javax.cache.Cache.Entry<K,V>>
 
 public interface IgniteCache<K,V> extends javax.cache.Cache<K,V>, IgniteAsyncSupport Main entry point for all Data Grid APIs. You can get a named cache by callingIgnite.cache(String)method.FunctionalityThis API extendsCacheAPI which containsJCache (JSR107)cache functionality and documentation. In addition toCachefunctionality this API provides:- Ability to perform basic atomic Map-like operations available on JCacheAPI.
- Ability to bulk load cache via loadCache(IgniteBiPredicate, Object...)method.
- Distributed lock functionality via lock(Object)methods.
- Ability to query cache using Predicate, SQL, and Text queries via query(Query)method.
- Ability to collect cache and query metrics.
- Ability to force partition rebalancing via rebalance()methopd (in case if delayed rebalancing was configured.)
- Ability to peek into memory without doing actual get(...)from cache vialocalPeek(Object, CachePeekMode...)methods
- Ability to evict and promote entries from on-heap to off-heap or swap and back.
- Ability to atomically collocate compute and data via invoke(Object, CacheEntryProcessor, Object...)methods.
 TransactionsCache API supports transactions. You can group and set of cache methods within a transaction to provide ACID-compliant behavior. SeeIgniteTransactionsfor more information.
 Methods which can be used inside transaction (put, get...) throw TransactionException. SeeTransactionExceptionfor more information.
- 
- 
Method SummaryAll Methods Instance Methods Abstract Methods Deprecated Methods Modifier and Type Method Description voidclear()Clears the contents of the cache, without notifying listeners orCacheWriters.voidclear(K key)Clears entry from the cache and swap storage, without notifying listeners orCacheWriters.voidclearAll(Set<? extends K> keys)Clears entries from the cache and swap storage, without notifying listeners orCacheWriters.IgniteFuture<Void>clearAllAsync(Set<? extends K> keys)Asynchronously clears entries from the cache and swap storage, without notifying listeners orCacheWriters.IgniteFuture<Void>clearAsync()Asynchronously clears the contents of the cache, without notifying listeners orCacheWriters.IgniteFuture<Void>clearAsync(K key)Asynchronously clears entry from the cache and swap storage, without notifying listeners orCacheWriters.voidclearStatistics()Clear cluster statistics for this cache.voidclose()Closes this cache instance.booleancontainsKey(K key)IgniteFuture<Boolean>containsKeyAsync(K key)Asynchronously determines if theCachecontains an entry for the specified key.booleancontainsKeys(Set<? extends K> keys)Determines if theCachecontains entries for the specified keys.IgniteFuture<Boolean>containsKeysAsync(Set<? extends K> keys)Asynchronously determines if theCachecontains entries for the specified keys.voiddestroy()Completely deletes the cache with all its data from the system on all cluster nodes.voidenableStatistics(boolean enabled)Sets statistics enabled flag cluster wide for this cache.Vget(K key)Map<K,V>getAll(Set<? extends K> keys)IgniteFuture<Map<K,V>>getAllAsync(Set<? extends K> keys)Asynchronously gets a collection of entries from theCache, returning them asMapof the values associated with the set of keys requested.Map<K,V>getAllOutTx(Set<? extends K> keys)Gets values from cache.IgniteFuture<Map<K,V>>getAllOutTxAsync(Set<? extends K> keys)Asynchronously gets values from cache.VgetAndPut(K key, V val)IgniteFuture<V>getAndPutAsync(K key, V val)Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed as the future result.VgetAndPutIfAbsent(K key, V val)Stores given key-value pair in cache only if cache had no previous mapping for it.IgniteFuture<V>getAndPutIfAbsentAsync(K key, V val)Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.VgetAndRemove(K key)IgniteFuture<V>getAndRemoveAsync(K key)Asynchronously removes the entry for a key only if currently mapped to some value.VgetAndReplace(K key, V val)IgniteFuture<V>getAndReplaceAsync(K key, V val)Asynchronously replaces the value for a given key if and only if there is a value currently mapped by the key.IgniteFuture<V>getAsync(K key)Asynchronously gets an entry from the cache.<C extends javax.cache.configuration.Configuration<K,V>>
 CgetConfiguration(Class<C> clazz)Collection<CacheEntry<K,V>>getEntries(Set<? extends K> keys)Gets a collection of entries from theCache.IgniteFuture<Collection<CacheEntry<K,V>>>getEntriesAsync(Set<? extends K> keys)Asynchronously gets a collection of entries from theCache.CacheEntry<K,V>getEntry(K key)Gets an entry from the cache.IgniteFuture<CacheEntry<K,V>>getEntryAsync(K key)Asynchronously gets an entry from the cache.IgniteFuture<?>indexReadyFuture()Returns future that will be completed when all indexes for this cache are ready to use.<T> Tinvoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)<T> Tinvoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)Invokes anCacheEntryProcessoragainst theCache.Entryspecified by the provided key.<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)Asynchronously invokes eachEntryProcessorfrom map's values against the correspondentCache.Entryspecified by map's key set.<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>invokeAll(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)Invokes anCacheEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)Asynchronous version of theinvokeAll(Map, Object...)method.<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)Asynchronously invokes anEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>>invokeAllAsync(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)Asynchronously invokes anCacheEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.<T> IgniteFuture<T>invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)Asynchronously invokes anEntryProcessoragainst theCache.Entryspecified by the provided key.<T> IgniteFuture<T>invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)Asynchronously invokes anCacheEntryProcessoragainst theCache.Entryspecified by the provided key.booleanisLocalLocked(K key, boolean byCurrThread)Checks if specified key is locked.voidloadCache(@Nullable IgniteBiPredicate<K,V> p, @Nullable Object... args)ExecuteslocalLoadCache(IgniteBiPredicate, Object...)on all cache nodes.IgniteFuture<Void>loadCacheAsync(@Nullable IgniteBiPredicate<K,V> p, @Nullable Object... args)Asynchronously executeslocalLoadCache(IgniteBiPredicate, Object...)on all cache nodes.voidlocalClear(K key)Clears entry from the cache and swap storage, without notifying listeners orCacheWriters.voidlocalClearAll(Set<? extends K> keys)Clears entries from the cache and swap storage, without notifying listeners orCacheWriters.Iterable<javax.cache.Cache.Entry<K,V>>localEntries(CachePeekMode... peekModes)Allows for iteration over local cache entries.voidlocalEvict(Collection<? extends K> keys)Attempts to evict all entries associated with keys.voidlocalLoadCache(@Nullable IgniteBiPredicate<K,V> p, @Nullable Object... args)Delegates toCacheStore.loadCache(IgniteBiInClosure,Object...)method to load state from the underlying persistent storage.IgniteFuture<Void>localLoadCacheAsync(@Nullable IgniteBiPredicate<K,V> p, @Nullable Object... args)Asynchronously loads state from the underlying persistent storage by delegating toCacheStore.loadCache(IgniteBiInClosure,Object...)method.CacheMetricslocalMetrics()Gets local snapshot metrics (statistics) for this cache.VlocalPeek(K key, CachePeekMode... peekModes)Peeks at a value in the local storage using an optional peek mode.booleanlocalPreloadPartition(int partition)Efficiently preloads cache partition into page memory if it exists on the local node.intlocalSize(CachePeekMode... peekModes)Gets the number of all entries cached on this node.longlocalSizeLong(int partition, CachePeekMode... peekModes)Gets the number of all entries cached on this node for the partition as a long value.longlocalSizeLong(CachePeekMode... peekModes)Gets the number of all entries cached on this node as a long value.Locklock(K key)Creates aLockinstance associated with passed key.LocklockAll(Collection<? extends K> keys)Deprecated.It is recommended to useIgnite.reentrantLock(String, boolean, boolean, boolean)instead.Collection<Integer>lostPartitions()Gets a collection of lost partition IDs.CacheMetricsmetrics()Gets whole cluster snapshot metrics (statistics) for this cache.CacheMetricsmetrics(ClusterGroup grp)Gets cluster group snapshot metrics for caches in cluster group.voidpreloadPartition(int partition)Efficiently preloads cache primary partition into page memory.IgniteFuture<Void>preloadPartitionAsync(int partition)Efficiently preloads cache partition into page memory.voidput(K key, V val)voidputAll(Map<? extends K,? extends V> map)IgniteFuture<Void>putAllAsync(Map<? extends K,? extends V> map)Asynchronously copies all of the entries from the specified map to theCache.IgniteFuture<Void>putAsync(K key, V val)Asynchronously associates the specified value with the specified key in the cache.booleanputIfAbsent(K key, V val)IgniteFuture<Boolean>putIfAbsentAsync(K key, V val)Asynchronously associates the specified key with the given value if it is not already associated with a value.<R> QueryCursor<R>query(Query<R> qry)Queries cache.<T,R>
 QueryCursor<R>query(Query<T> qry, IgniteClosure<T,R> transformer)Queries the cache transforming the entries on the server nodes.FieldsQueryCursor<List<?>>query(SqlFieldsQuery qry)Queries cache.Collection<? extends QueryDetailMetrics>queryDetailMetrics()Gets query detail metrics.QueryMetricsqueryMetrics()Gets query metrics.IgniteFuture<Boolean>rebalance()Deprecated.Use baseline topology feature instead.booleanremove(K key)booleanremove(K key, V oldVal)voidremoveAll()Removes all of the mappings from this cache.voidremoveAll(Set<? extends K> keys)IgniteFuture<Void>removeAllAsync()Asynchronously removes all of the mappings from this cache.IgniteFuture<Void>removeAllAsync(Set<? extends K> keys)Asynchronously removes entries for the specified keys.IgniteFuture<Boolean>removeAsync(K key)Asynchronously removes the mapping for a key from this cache if it is present.IgniteFuture<Boolean>removeAsync(K key, V oldVal)Asynchronously removes the mapping for a key only if currently mapped to the given value.booleanreplace(K key, V val)booleanreplace(K key, V oldVal, V newVal)IgniteFuture<Boolean>replaceAsync(K key, V val)Asynchronously replaces the entry for a key only if currently mapped to a given value.IgniteFuture<Boolean>replaceAsync(K key, V oldVal, V newVal)Asynchronous version of thereplace(Object, Object, Object).voidresetQueryDetailMetrics()Reset query detail metrics.voidresetQueryMetrics()Reset query metrics.intsize(CachePeekMode... peekModes)Gets the number of all entries cached across all nodes.IgniteFuture<Integer>sizeAsync(CachePeekMode... peekModes)Asynchronously gets the number of all entries cached across all nodes.longsizeLong(int partition, CachePeekMode... peekModes)Gets the number of all entries cached in a partition as a long value.longsizeLong(CachePeekMode... peekModes)Gets the number of all entries cached across all nodes as a long value.IgniteFuture<Long>sizeLongAsync(int partition, CachePeekMode... peekModes)Asynchronously gets the number of all entries cached in a partition as a long value.IgniteFuture<Long>sizeLongAsync(CachePeekMode... peekModes)Asynchronously gets the number of all entries cached across all nodes as a long value.IgniteCache<K,V>withAsync()Deprecated.IgniteCache<K,V>withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)Returns cache with the specified expired policy set.<K1,V1>
 IgniteCache<K1,V1>withKeepBinary()Returns cache that will operate with binary objects.IgniteCache<K,V>withNoRetries()IgniteCache<K,V>withPartitionRecover()Gets an instance ofIgniteCachethat will be allowed to execute cache read operations regardless of partition loss policy.IgniteCache<K,V>withReadRepair(ReadRepairStrategy strategy)This is an experimental API.IgniteCache<K,V>withSkipStore()- 
Methods inherited from interface javax.cache.CachederegisterCacheEntryListener, getCacheManager, getName, isClosed, iterator, loadAll, registerCacheEntryListener, unwrap
 - 
Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupportfuture, isAsync
 - 
Methods inherited from interface java.lang.IterableforEach, spliterator
 
- 
 
- 
- 
- 
Method Detail- 
withAsync@Deprecated IgniteCache<K,V> withAsync() Deprecated.Gets instance of this component with asynchronous mode enabled.- Specified by:
- withAsyncin interface- IgniteAsyncSupport
- Returns:
- Instance of this component with asynchronous mode enabled.
 
 - 
getConfiguration<C extends javax.cache.configuration.Configuration<K,V>> C getConfiguration(Class<C> clazz) 
 - 
withExpiryPolicyIgniteCache<K,V> withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc) Returns cache with the specified expired policy set. This policy will be used for each operation invoked on the returned cache.This method does not modify existing cache instance. - Parameters:
- plc- Expire policy to use.
- Returns:
- Cache instance with the specified expiry policy set.
 
 - 
withSkipStoreIgniteCache<K,V> withSkipStore() - Returns:
- Cache with read-through write-through behavior disabled.
 
 - 
withNoRetriesIgniteCache<K,V> withNoRetries() - Returns:
- Cache with no-retries behavior enabled.
 
 - 
withPartitionRecoverIgniteCache<K,V> withPartitionRecover() Gets an instance ofIgniteCachethat will be allowed to execute cache read operations regardless of partition loss policy.- Returns:
- Cache without partition loss protection.
 
 - 
withReadRepairIgniteCache<K,V> withReadRepair(ReadRepairStrategy strategy) This is an experimental API.Gets an instance of IgniteCachethat will perform backup nodes check on each get attempt.Read Repair means that each backup node will be checked to have the same entry as the primary node has. In case consistency violations were found, the values across the topology will be replaced by repaired values according to the chosen strategy, see ReadRepairStrategyfor the details.A consistency violation exception will be thrown when the repair is impossible. CacheConsistencyViolationEventwill be recorded for each violation in case it's configured as recordable.- For transactional caches, values will be repaired:
  - automatically for transactions that have TransactionConcurrency.OPTIMISTICconcurrency mode orTransactionIsolation.READ_COMMITTEDisolation level,
- at commit() phase for transactions that have TransactionConcurrency.PESSIMISTICconcurrency mode and isolation level other thanTransactionIsolation.READ_COMMITTED
 This proxy usage does not guarantee "all copies check" in case the value have been already cached inside the transaction. In case you don't use a READ_COMMITTED isolation mode and already have a cached value, for example have already read the value or performed a write, you'll just get the cached value. 
- automatically for transactions that have 
- For atomic caches, values will be repaired automatically.
  Warning: Due to the nature of an atomic cache, false-positive results can be observed. For example, an attempt to check consistency under cache's loading may lead to a consistency violation exception. By default, the implementation tries to check the given key three times. The number of attempts can be changed using IgniteSystemProperties.IGNITE_NEAR_GET_MAX_REMAPSproperty.
 - Caches without backups.
- Near caches.
- Caches that use "read-through" mode.
 Full list of repairable methods: - containsKey(K)&&- containsKeyAsync(K)
- containsKeys(java.util.Set<? extends K>)&&- containsKeysAsync(java.util.Set<? extends K>)
- getEntry(K)&&- getEntryAsync(K)
- getEntries(java.util.Set<? extends K>)&&- getEntriesAsync(java.util.Set<? extends K>)
- get(K)&&- getAsync(K)
- getAll(java.util.Set<? extends K>)&&- getAllAsync(java.util.Set<? extends K>)
 - Parameters:
- strategy- Read Repair strategy.
- Returns:
- Cache with explicit consistency check on each read and repair if necessary.
 
- For transactional caches, values will be repaired:
  
 - 
withKeepBinary<K1,V1> IgniteCache<K1,V1> withKeepBinary() Returns cache that will operate with binary objects.Cache returned by this method will not be forced to deserialize binary objects, so keys and values will be returned from cache API methods without changes. Therefore, signature of the cache can contain only following types: - org.apache.ignite.binary.BinaryObjectfor binary classes
- All primitives (byte, int, ...) and there boxed versions (Byte, Integer, ...)
- Arrays of primitives (byte[], int[], ...)
- Stringand array of- Strings
- UUIDand array of- UUIDs
- Dateand array of- Dates
- Timestampand array of- Timestamps
- Enums and array of enums
- Maps, collections and array of objects (but objects inside them will still be converted if they are binary)
 For example, if you use Integeras a key andValueclass as a value (which will be stored in binary format), you should acquire following projection to avoid deserialization:IgniteCache<Integer, BinaryObject> prj = cache.withKeepBinary(); // Value is not deserialized and returned in binary format. BinaryObject po = prj.get(1); Note that this method makes sense only if cache is working in binary mode if default marshaller is used. If not, this method is no-op and will return current cache. - Type Parameters:
- V1- Type of the cache value binary objects.
- K1- Type of the cache key.
- Returns:
- New cache instance for binary objects.
 
 - 
loadCache@IgniteAsyncSupported void loadCache(@Nullable @Nullable IgniteBiPredicate<K,V> p, @Nullable @Nullable Object... args) throws javax.cache.CacheException ExecuteslocalLoadCache(IgniteBiPredicate, Object...)on all cache nodes.- Parameters:
- p- Optional predicate (may be- null). If provided, will be used to filter values loaded from storage before they are put into cache.
- args- Optional user arguments to be passed into- CacheStore.loadCache(IgniteBiInClosure, Object...)method.
- Throws:
- javax.cache.CacheException- If loading failed.
 
 - 
loadCacheAsyncIgniteFuture<Void> loadCacheAsync(@Nullable @Nullable IgniteBiPredicate<K,V> p, @Nullable @Nullable Object... args) throws javax.cache.CacheException Asynchronously executeslocalLoadCache(IgniteBiPredicate, Object...)on all cache nodes.- Parameters:
- p- Optional predicate (may be- null). If provided, will be used to filter values loaded from storage before they are put into cache.
- args- Optional user arguments to be passed into- CacheStore.loadCache(IgniteBiInClosure, Object...)method.
- Returns:
- a Future representing pending completion of the cache loading.
- Throws:
- javax.cache.CacheException- If loading failed.
 
 - 
localLoadCache@IgniteAsyncSupported void localLoadCache(@Nullable @Nullable IgniteBiPredicate<K,V> p, @Nullable @Nullable Object... args) throws javax.cache.CacheException Delegates toCacheStore.loadCache(IgniteBiInClosure,Object...)method to load state from the underlying persistent storage. The loaded values will then be given to the optionally passed in predicate, and, if the predicate returnstrue, will be stored in cache. If predicate isnull, then all loaded values will be stored in cache.Note that this method does not receive keys as a parameter, so it is up to CacheStoreimplementation to provide all the data to be loaded.This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches. - Parameters:
- p- Optional predicate (may be- null). If provided, will be used to filter values to be put into cache.
- args- Optional user arguments to be passed into- CacheStore.loadCache(IgniteBiInClosure, Object...)method.
- Throws:
- javax.cache.CacheException- If loading failed.
 
 - 
localLoadCacheAsyncIgniteFuture<Void> localLoadCacheAsync(@Nullable @Nullable IgniteBiPredicate<K,V> p, @Nullable @Nullable Object... args) throws javax.cache.CacheException Asynchronously loads state from the underlying persistent storage by delegating toCacheStore.loadCache(IgniteBiInClosure,Object...)method. The loaded values will then be given to the optionally passed in predicate, and, if the predicate returnstrue, will be stored in cache. If predicate isnull, then all loaded values will be stored in cache.Note that this method does not receive keys as a parameter, so it is up to CacheStoreimplementation to provide all the data to be loaded.This method is not transactional and may end up loading a stale value into cache if another thread has updated the value immediately after it has been loaded. It is mostly useful when pre-loading the cache from underlying data store before start, or for read-only caches. - Parameters:
- p- Optional predicate (may be- null). If provided, will be used to filter values to be put into cache.
- args- Optional user arguments to be passed into- CacheStore.loadCache(IgniteBiInClosure, Object...)method.
- Returns:
- a Future representing pending completion of the cache loading.
- Throws:
- javax.cache.CacheException- If loading failed.
 
 - 
getAndPutIfAbsent@IgniteAsyncSupported V getAndPutIfAbsent(K key, V val) throws javax.cache.CacheException, TransactionException Stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case ofCacheMode.PARTITIONEDorCacheMode.REPLICATEDcaches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage,CacheLoader.load(Object)method will be used.If the returned value is not needed, method putIfAbsent(Object, Object)should always be used instead of this one to avoid the overhead associated with returning of the previous value.If write-through is enabled, the stored value will be persisted to CacheStoreviaCacheWriter.write(javax.cache.Cache.Entry)method.TransactionsThis method is transactional and will enlist the entry into ongoing transaction if there is one.- Parameters:
- key- Key to store in cache.
- val- Value to be associated with the given key.
- Returns:
- Previously contained value regardless of whether put happened or not (nullif there was no previous value).
- Throws:
- NullPointerException- If either key or value are- null.
- javax.cache.CacheException- If put operation failed.
- TransactionException- If operation within transaction is failed.
 
 - 
getAndPutIfAbsentAsyncIgniteFuture<V> getAndPutIfAbsentAsync(K key, V val) throws javax.cache.CacheException, TransactionException Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it. If cache previously contained value for the given key, then this value is returned. In case ofCacheMode.PARTITIONEDorCacheMode.REPLICATEDcaches, the value will be loaded from the primary node, which in its turn may load the value from the swap storage, and consecutively, if it's not in swap, from the underlying persistent storage. If value has to be loaded from persistent storage,CacheLoader.load(Object)method will be used.If the returned value is not needed, method putIfAbsentAsync(Object, Object)should always be used instead of this one to avoid the overhead associated with returning of the previous value.If write-through is enabled, the stored value will be persisted to CacheStoreviaCacheWriter.write(javax.cache.Cache.Entry)method.TransactionsThis method is transactional and will enlist the entry into ongoing transaction if there is one.- Parameters:
- key- Key to store in cache.
- val- Value to be associated with the given key.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- NullPointerException- If either key or value are- null.
- javax.cache.CacheException- If put operation failed.
- TransactionException- If operation within transaction is failed.
 
 - 
lockLock lock(K key) Creates aLockinstance associated with passed key. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not supportLock.newCondition()method, other methods defined inLockare supported.- Parameters:
- key- Key for lock.
- Returns:
- New lock instance associated with passed key.
- See Also:
- Lock.lock(),- Lock.tryLock(long, TimeUnit)
 
 - 
lockAllLock lockAll(Collection<? extends K> keys) Deprecated.It is recommended to useIgnite.reentrantLock(String, boolean, boolean, boolean)instead. This method will be removed in future releases.Creates aLockinstance associated with passed keys. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not supportLock.newCondition()method, other methods defined inLockare supported.- Parameters:
- keys- Keys for lock.
- Returns:
- New lock instance associated with passed key.
- See Also:
- Lock.lock(),- Lock.tryLock(long, TimeUnit)
 
 - 
isLocalLockedboolean isLocalLocked(K key, boolean byCurrThread) Checks if specified key is locked.This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way. - Parameters:
- key- Key to check.
- byCurrThread- If- truemethod will check that current thread owns a lock on this key, otherwise will check that any thread on any node owns a lock on this key.
- Returns:
- Trueif lock is owned by some node.
 
 - 
query<R> QueryCursor<R> query(Query<R> qry) Queries cache. Accepts any subclass ofQueryinterface. See alsoquery(SqlFieldsQuery).- Type Parameters:
- R- Type of the query result.
- Parameters:
- qry- Query.
- Returns:
- Cursor.
- See Also:
- ScanQuery,- SqlFieldsQuery,- TextQuery,- SpiQuery
 
 - 
queryFieldsQueryCursor<List<?>> query(SqlFieldsQuery qry) Queries cache. AcceptsSqlFieldsQueryclass.- Parameters:
- qry- SqlFieldsQuery.
- Returns:
- Cursor.
- See Also:
- SqlFieldsQuery
 
 - 
query<T,R> QueryCursor<R> query(Query<T> qry, IgniteClosure<T,R> transformer) Queries the cache transforming the entries on the server nodes. Can be used, for example, to avoid network overhead in case only one field out of the large is required by client.Currently transformers are supported ONLY for ScanQuery. Passing any other subclass ofQueryinterface to this method will end up withUnsupportedOperationException.- Type Parameters:
- T- Type of the initial query result.
- R- Type of the transformed query result.
- Parameters:
- qry- Query.
- transformer- Transformer.
- Returns:
- Cursor.
 
 - 
localEntriesIterable<javax.cache.Cache.Entry<K,V>> localEntries(CachePeekMode... peekModes) throws javax.cache.CacheException Allows for iteration over local cache entries.- Parameters:
- peekModes- Peek modes.
- Returns:
- Iterable over local cache entries.
- Throws:
- javax.cache.CacheException- If failed.
 
 - 
queryMetricsQueryMetrics queryMetrics() Gets query metrics.- Returns:
- Metrics.
 
 - 
resetQueryMetricsvoid resetQueryMetrics() Reset query metrics.
 - 
queryDetailMetricsCollection<? extends QueryDetailMetrics> queryDetailMetrics() Gets query detail metrics. Query detail metrics could be enabled viaCacheConfiguration.setQueryDetailMetricsSize(int)method.- Returns:
- Metrics.
 
 - 
resetQueryDetailMetricsvoid resetQueryDetailMetrics() Reset query detail metrics.
 - 
localEvictvoid localEvict(Collection<? extends K> keys) Attempts to evict all entries associated with keys. Note, that entry will be evicted only if it's not used (not participating in any locks or transactions).- Parameters:
- keys- Keys to evict.
 
 - 
localPeekV localPeek(K key, CachePeekMode... peekModes) Peeks at a value in the local storage using an optional peek mode.This method will not load a value from the configured CacheStoreor from a remote node.TransactionsThis method does not participate in any transactions.- Parameters:
- key- Entry key.
- peekModes- Peek modes.
- Returns:
- Peeked value, or nullif not found.
- Throws:
- NullPointerException- If key is- null.
 
 - 
size@IgniteAsyncSupported int size(CachePeekMode... peekModes) throws javax.cache.CacheException Gets the number of all entries cached across all nodes. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their cache sizes. - Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- Cache size across all nodes.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
sizeAsyncIgniteFuture<Integer> sizeAsync(CachePeekMode... peekModes) throws javax.cache.CacheException Asynchronously gets the number of all entries cached across all nodes. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their cache sizes. - Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
sizeLong@IgniteAsyncSupported long sizeLong(CachePeekMode... peekModes) throws javax.cache.CacheException Gets the number of all entries cached across all nodes as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their cache sizes. - Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- Cache size across all nodes.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
sizeLongAsyncIgniteFuture<Long> sizeLongAsync(CachePeekMode... peekModes) throws javax.cache.CacheException Asynchronously gets the number of all entries cached across all nodes as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their cache sizes. - Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
sizeLong@IgniteAsyncSupported long sizeLong(int partition, CachePeekMode... peekModes) throws javax.cache.CacheException Gets the number of all entries cached in a partition as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their partition cache sizes. - Parameters:
- partition- partition.
- peekModes- Optional peek modes. If not provided, then total partition cache size is returned.
- Returns:
- Partition cache size across all nodes.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
sizeLongAsyncIgniteFuture<Long> sizeLongAsync(int partition, CachePeekMode... peekModes) throws javax.cache.CacheException Asynchronously gets the number of all entries cached in a partition as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies across all nodes will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.NOTE: this operation is distributed and will query all participating nodes for their partition cache sizes. - Parameters:
- partition- partition.
- peekModes- Optional peek modes. If not provided, then total partition cache size is returned.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- javax.cache.CacheException- On error.
 
 - 
localSizeint localSize(CachePeekMode... peekModes) Gets the number of all entries cached on this node. By default, ifpeekModesvalue isn't defined, only size of primary copies will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.- Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- Cache size on this node.
 
 - 
localSizeLonglong localSizeLong(CachePeekMode... peekModes) Gets the number of all entries cached on this node as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.- Parameters:
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- Cache size on this node.
 
 - 
localSizeLonglong localSizeLong(int partition, CachePeekMode... peekModes)Gets the number of all entries cached on this node for the partition as a long value. By default, ifpeekModesvalue isn't defined, only size of primary copies will be returned. This behavior is identical to calling this method withCachePeekMode.PRIMARYpeek mode.- Parameters:
- partition- partition.
- peekModes- Optional peek modes. If not provided, then total cache size is returned.
- Returns:
- Cache size on this node.
 
 - 
invokeAll@IgniteAsyncSupported <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) throws TransactionException Asynchronously invokes eachEntryProcessorfrom map's values against the correspondentCache.Entryspecified by map's key set.If an Cache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key and a value of null is provided.The order that the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same EntryProcessorinstance to process each entry, as the case may be in a non-local cache topology.The result of executing the EntryProcessoris returned in the future as aMapofEntryProcessorResults, one result per key. Should theEntryProcessoror Caching implementation throw an exception, the exception is wrapped and re-thrown when a call toEntryProcessorResult.get()is made.Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.Keys are locked in the order in which they appear in map. It is caller's responsibility to make sure keys always follow same order, such as by using TreeMap. Using unordered map, such asHashMap, while calling this method in parallel will lead to deadlock.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- map- Map containing keys and entry processors to be applied to values.
- args- Additional arguments to pass to the- EntryProcessor.
- Returns:
- The map of EntryProcessorResults of the processing per key, if any, defined by theEntryProcessorimplementation. No mappings will be returned forEntryProcessors that return anullvalue for a key.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
invokeAllAsync<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args) throws TransactionException Asynchronous version of theinvokeAll(Map, Object...)method.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- map- Map containing keys and entry processors to be applied to values.
- args- Additional arguments to pass to the- EntryProcessor.
- Returns:
- a Future representing pending completion of the operation. See more about future result
 at the invokeAll(Map, Object...).
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
get@IgniteAsyncSupported V get(K key) throws TransactionException - Specified by:
- getin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAsyncIgniteFuture<V> getAsync(K key) Asynchronously gets an entry from the cache.If the cache is configured to use read-through, and a future result would be null because the entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry.- Parameters:
- key- Key.
- Returns:
- a Future representing pending completion of the operation.
 
 - 
getEntry@IgniteAsyncSupported CacheEntry<K,V> getEntry(K key) throws TransactionException Gets an entry from the cache.If the cache is configured to use read-through, and get would return null because the entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry.- Parameters:
- key- The key whose associated value is to be returned.
- Returns:
- The element, or null, if it does not exist.
- Throws:
- IllegalStateException- If the cache is- Cache.isClosed().
- NullPointerException- If the key is- null.
- javax.cache.CacheException- If there is a problem fetching the value.
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
 
 - 
getEntryAsyncIgniteFuture<CacheEntry<K,V>> getEntryAsync(K key) throws TransactionException Asynchronously gets an entry from the cache.If the cache is configured to use read-through, and a future result would be null because the entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry.- Parameters:
- key- The key whose associated value is to be returned.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- IllegalStateException- If the cache is- Cache.isClosed().
- NullPointerException- If the key is- null.
- javax.cache.CacheException- If there is a problem fetching the value.
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
 
 - 
getAll@IgniteAsyncSupported Map<K,V> getAll(Set<? extends K> keys) throws TransactionException - Specified by:
- getAllin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAllAsyncIgniteFuture<Map<K,V>> getAllAsync(Set<? extends K> keys) throws TransactionException Asynchronously gets a collection of entries from theCache, returning them asMapof the values associated with the set of keys requested.If the cache is configured read-through, and a future result for a key would be null because an entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry. If an entry cannot be loaded for a given key, the key will not be present in the returned Map.- Parameters:
- keys- Keys set.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getEntries@IgniteAsyncSupported Collection<CacheEntry<K,V>> getEntries(Set<? extends K> keys) throws TransactionException Gets a collection of entries from theCache.If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry. If an entry cannot be loaded for a given key, the key will not be present in the returned Collection.- Parameters:
- keys- The keys whose associated values are to be returned.
- Returns:
- A collection of entries that were found for the given keys. Entries not found in the cache are not in the returned collection.
- Throws:
- NullPointerException- If keys is null or if keys contains a- null.
- IllegalStateException- If the cache is- Cache.isClosed().
- javax.cache.CacheException- If there is a problem fetching the values.
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
 
 - 
getEntriesAsyncIgniteFuture<Collection<CacheEntry<K,V>>> getEntriesAsync(Set<? extends K> keys) throws TransactionException Asynchronously gets a collection of entries from theCache.If the cache is configured read-through, and a future result for a key would be null because an entry is missing from the cache, the Cache's CacheLoaderis called in an attempt to load the entry. If an entry cannot be loaded for a given key, the key will not be present in the returned Collection.- Parameters:
- keys- The keys whose associated values are to be returned.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- NullPointerException- If keys is null or if keys contains a- null.
- IllegalStateException- If the cache is- Cache.isClosed().
- javax.cache.CacheException- If there is a problem fetching the values.
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
 
 - 
getAllOutTx@IgniteAsyncSupported Map<K,V> getAllOutTx(Set<? extends K> keys) Gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.- Parameters:
- keys- The keys whose associated values are to be returned.
- Returns:
- A map of entries that were found for the given keys.
 
 - 
getAllOutTxAsyncIgniteFuture<Map<K,V>> getAllOutTxAsync(Set<? extends K> keys) Asynchronously gets values from cache. Will bypass started transaction, if any, i.e. will not enlist entries and will not lock any keys if pessimistic transaction is started by thread.- Parameters:
- keys- The keys whose associated values are to be returned.
- Returns:
- a Future representing pending completion of the operation.
 
 - 
containsKey@IgniteAsyncSupported boolean containsKey(K key) throws TransactionException - Specified by:
- containsKeyin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
containsKeyAsyncIgniteFuture<Boolean> containsKeyAsync(K key) throws TransactionException Asynchronously determines if theCachecontains an entry for the specified key.More formally, future result is true if and only if this cache contains a mapping for a key k such that key.equals(k). (There can be at most one such mapping.) - Parameters:
- key- Key.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
containsKeys@IgniteAsyncSupported boolean containsKeys(Set<? extends K> keys) throws TransactionException Determines if theCachecontains entries for the specified keys.- Parameters:
- keys- Key whose presence in this cache is to be tested.
- Returns:
- Trueif this cache contains a mapping for the specified keys.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
containsKeysAsyncIgniteFuture<Boolean> containsKeysAsync(Set<? extends K> keys) throws TransactionException Asynchronously determines if theCachecontains entries for the specified keys.- Parameters:
- keys- Key whose presence in this cache is to be tested.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
put@IgniteAsyncSupported void put(K key, V val) throws TransactionException - Specified by:
- putin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
putAsyncIgniteFuture<Void> putAsync(K key, V val) throws TransactionException Asynchronously associates the specified value with the specified key in the cache.If the Cachepreviously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only ifc.containsKey(k)would return true.)- Parameters:
- key- Key.
- val- Value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndPut@IgniteAsyncSupported V getAndPut(K key, V val) throws TransactionException - Specified by:
- getAndPutin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndPutAsyncIgniteFuture<V> getAndPutAsync(K key, V val) throws TransactionException Asynchronously associates the specified value with the specified key in this cache, returning an existing value if one existed as the future result.If the cache previously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only if c.containsKey(k)would return true.)The previous value is returned as the future result, or future result is null if there was no value associated with the key previously. - Parameters:
- key- Key.
- val- Value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
putAll@IgniteAsyncSupported void putAll(Map<? extends K,? extends V> map) throws TransactionException Keys are locked in the order in which they appear in map. It is caller's responsibility to make sure keys always follow same order, such as by using TreeMap. Using unordered map, such asHashMap, while calling this method in parallel will lead to deadlock.- Specified by:
- putAllin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
putAllAsyncIgniteFuture<Void> putAllAsync(Map<? extends K,? extends V> map) throws TransactionException Asynchronously copies all of the entries from the specified map to theCache.The effect of this call is equivalent to that of calling putAsync(Object, Object)putAsync(k, v)} on this cache once for each mapping from key k to value v in the specified map.The order in which the individual puts occur is undefined. The behavior of this operation is undefined if entries in the cache corresponding to entries in the map are modified or removed while this operation is in progress. or if map is modified while the operation is in progress. In Default Consistency mode, individual puts occur atomically but not the entire putAll. Listeners may observe individual updates. Keys are locked in the order in which they appear in map. It is caller's responsibility to make sure keys always follow same order, such as by using TreeMap. Using unordered map, such asHashMap, while calling this method in parallel will lead to deadlock.- Parameters:
- map- Map containing keys and values to put into the cache.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
putIfAbsent@IgniteAsyncSupported boolean putIfAbsent(K key, V val) throws TransactionException For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Specified by:
- putIfAbsentin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
putIfAbsentAsyncIgniteFuture<Boolean> putIfAbsentAsync(K key, V val) Asynchronously associates the specified key with the given value if it is not already associated with a value.For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Parameters:
- key- Key.
- val- Value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionTimeoutException- If operation performs within transaction and timeout occurred.
- TransactionRollbackException- If operation performs within transaction that automatically rolled back.
- TransactionHeuristicException- If operation performs within transaction that entered an unknown state.
 
 - 
remove@IgniteAsyncSupported boolean remove(K key) throws TransactionException - Specified by:
- removein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
removeAsyncIgniteFuture<Boolean> removeAsync(K key) throws TransactionException Asynchronously removes the mapping for a key from this cache if it is present.More formally, if this cache contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The cache can contain at most one such mapping.)A future result is true if this cache previously associated the key, or false if the cache contained no mapping for the key. The cache will not contain a mapping for the specified key once the returned future is completed. - Parameters:
- key- Key.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
remove@IgniteAsyncSupported boolean remove(K key, V oldVal) throws TransactionException For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Specified by:
- removein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
removeAsyncIgniteFuture<Boolean> removeAsync(K key, V oldVal) throws TransactionException Asynchronously removes the mapping for a key only if currently mapped to the given value.For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Parameters:
- key- Key.
- oldVal- Old value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndRemove@IgniteAsyncSupported V getAndRemove(K key) throws TransactionException - Specified by:
- getAndRemovein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndRemoveAsyncIgniteFuture<V> getAndRemoveAsync(K key) throws TransactionException Asynchronously removes the entry for a key only if currently mapped to some value.- Parameters:
- key- Key.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
replace@IgniteAsyncSupported boolean replace(K key, V oldVal, V newVal) throws TransactionException For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Specified by:
- replacein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
replaceAsyncIgniteFuture<Boolean> replaceAsync(K key, V oldVal, V newVal) throws TransactionException Asynchronous version of thereplace(Object, Object, Object).For CacheAtomicityMode.ATOMICreturn value on primary node crash may be incorrect because of the automatic retries. It is recommended to disable retries withwithNoRetries()and manually restore primary-backup consistency in case of update failure.- Parameters:
- key- Key.
- oldVal- Old value.
- newVal- New value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
replace@IgniteAsyncSupported boolean replace(K key, V val) throws TransactionException - Specified by:
- replacein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
replaceAsyncIgniteFuture<Boolean> replaceAsync(K key, V val) throws TransactionException Asynchronously replaces the entry for a key only if currently mapped to a given value.- Parameters:
- key- Key.
- val- Value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndReplace@IgniteAsyncSupported V getAndReplace(K key, V val) throws TransactionException - Specified by:
- getAndReplacein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
getAndReplaceAsyncIgniteFuture<V> getAndReplaceAsync(K key, V val) Asynchronously replaces the value for a given key if and only if there is a value currently mapped by the key.- Parameters:
- key- Key.
- val- Value.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionTimeoutException- If operation performs within transaction and timeout occurred.
- TransactionRollbackException- If operation performs within transaction that automatically rolled back.
- TransactionHeuristicException- If operation performs within transaction that entered an unknown state.
 
 - 
removeAll@IgniteAsyncSupported void removeAll(Set<? extends K> keys) throws TransactionException Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Specified by:
- removeAllin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
removeAllAsyncIgniteFuture<Void> removeAllAsync(Set<? extends K> keys) throws TransactionException Asynchronously removes entries for the specified keys.The order in which the individual entries are removed is undefined. For every entry in the key set, the following are called: - any registered CacheEntryRemovedListeners
- if the cache is a write-through cache, the CacheWriter
 CacheWriteris not called.Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Parameters:
- keys- Keys set.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
- any registered 
 - 
removeAll@IgniteAsyncSupported void removeAll() Removes all of the mappings from this cache.The order that the individual entries are removed is undefined. For every mapping that exists the following are called: - any registered CacheEntryRemovedListeners
- if the cache is a write-through cache, the CacheWriter
 CacheWriteris not called.This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes. This is potentially an expensive operation as listeners are invoked. Use clear()to avoid this.- Specified by:
- removeAllin interface- javax.cache.Cache<K,V>
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the remove
- See Also:
- clear(),- CacheWriter.deleteAll(java.util.Collection<?>)
 
- any registered 
 - 
removeAllAsyncIgniteFuture<Void> removeAllAsync() Asynchronously removes all of the mappings from this cache.The order that the individual entries are removed is undefined. For every mapping that exists the following are called: - any registered CacheEntryRemovedListeners
- if the cache is a write-through cache, the CacheWriter
 CacheWriteris not called.This is potentially an expensive operation as listeners are invoked. Use clearAsync()to avoid this.- Returns:
- a Future representing pending completion of the operation.
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the remove
- See Also:
- clearAsync(),- CacheWriter.deleteAll(java.util.Collection<?>)
 
- any registered 
 - 
clear@IgniteAsyncSupported void clear() Clears the contents of the cache, without notifying listeners orCacheWriters. Entries are cleared only if they are not currently locked, and are not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Specified by:
- clearin interface- javax.cache.Cache<K,V>
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed().
- javax.cache.CacheException- if there is a problem during the clear.
 
 - 
clearAsyncIgniteFuture<Void> clearAsync() Asynchronously clears the contents of the cache, without notifying listeners orCacheWriters. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Returns:
- a Future representing pending completion of the operation.
 
 - 
clear@IgniteAsyncSupported void clear(K key) Clears entry from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Parameters:
- key- Key to clear.
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the clear
 
 - 
clearAsyncIgniteFuture<Void> clearAsync(K key) Asynchronously clears entry from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Parameters:
- key- Key to clear.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the clear
 
 - 
clearAll@IgniteAsyncSupported void clearAll(Set<? extends K> keys) Clears entries from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Parameters:
- keys- Keys to clear.
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the clear
 
 - 
clearAllAsyncIgniteFuture<Void> clearAllAsync(Set<? extends K> keys) Asynchronously clears entries from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.- Parameters:
- keys- Keys to clear.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- IllegalStateException- if the cache is- Cache.isClosed()
- javax.cache.CacheException- if there is a problem during the clear
 
 - 
localClearvoid localClear(K key) Clears entry from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes. Note that this operation is local as it merely clears an entry from local cache, it does not remove entries from remote caches.- Parameters:
- key- Key to clear.
 
 - 
localClearAllvoid localClearAll(Set<? extends K> keys) Clears entries from the cache and swap storage, without notifying listeners orCacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction. This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes. Note that this operation is local as it merely clears an entry from local cache, it does not remove entries from remote caches.- Parameters:
- keys- Keys to clear.
 
 - 
invoke@IgniteAsyncSupported <T> T invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments) throws TransactionException Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.- Specified by:
- invokein interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
invokeAsync<T> IgniteFuture<T> invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments) throws TransactionException Asynchronously invokes anEntryProcessoragainst theCache.Entryspecified by the provided key. If anCache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key with a null value is used instead.Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- key- The key to the entry.
- entryProcessor- The- EntryProcessorto invoke.
- arguments- Additional arguments to pass to the- EntryProcessor.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
invoke@IgniteAsyncSupported <T> T invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments) throws TransactionException Invokes anCacheEntryProcessoragainst theCache.Entryspecified by the provided key. If anCache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key with a null value is used instead.An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same. Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- key- The key to the entry.
- entryProcessor- The- CacheEntryProcessorto invoke.
- arguments- Additional arguments to pass to the- CacheEntryProcessor.
- Returns:
- The result of the processing, if any, defined by the CacheEntryProcessorimplementation.
- Throws:
- NullPointerException- If key or- CacheEntryProcessoris null
- IllegalStateException- If the cache is- Cache.isClosed()
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- javax.cache.processor.EntryProcessorException- If an exception is thrown by the- CacheEntryProcessor, a Caching Implementation must wrap any- Exceptionthrown wrapped in an- EntryProcessorException.
- TransactionException- If operation within transaction is failed.
- See Also:
- CacheEntryProcessor
 
 - 
invokeAsync<T> IgniteFuture<T> invokeAsync(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments) throws TransactionException Asynchronously invokes anCacheEntryProcessoragainst theCache.Entryspecified by the provided key. If anCache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key with a null value is used instead.An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same. - Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- key- The key to the entry.
- entryProcessor- The- CacheEntryProcessorto invoke.
- arguments- Additional arguments to pass to the- CacheEntryProcessor.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- NullPointerException- If key or- CacheEntryProcessoris null
- IllegalStateException- If the cache is- Cache.isClosed()
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- javax.cache.processor.EntryProcessorException- If an exception is thrown by the- CacheEntryProcessor, a Caching Implementation must wrap any- Exceptionthrown wrapped in an- EntryProcessorException.
- TransactionException- If operation within transaction is failed.
- See Also:
- CacheEntryProcessor
 
 - 
invokeAll@IgniteAsyncSupported <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) throws TransactionException Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Specified by:
- invokeAllin interface- javax.cache.Cache<K,V>
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
invokeAllAsync<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args) throws TransactionException Asynchronously invokes anEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.If an Cache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key and a value of null is provided.The order that the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same EntryProcessorinstance to process each entry, as the case may be in a non-local cache topology.The result of executing the EntryProcessoris returned in the future as aMapofEntryProcessorResults, one result per key. Should theEntryProcessoror Caching implementation throw an exception, the exception is wrapped and re-thrown when a call toEntryProcessorResult.get()is made.Please refer to documentation for CacheAtomicityMode.ATOMICfor information on system behavior in crash scenarios for atomic caches.Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- keys- The set of keys.
- entryProcessor- The- EntryProcessorto invoke.
- args- Additional arguments to pass to the- EntryProcessor.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- TransactionException- If operation within transaction is failed.
 
 - 
invokeAll@IgniteAsyncSupported <T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args) throws TransactionException Invokes anCacheEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.If an Cache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key and a value of null is provided.The order that the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same CacheEntryProcessorinstance to process each entry, as the case may be in a non-local cache topology.The result of executing the CacheEntryProcessoris returned as aMapofEntryProcessorResults, one result per key. Should theCacheEntryProcessoror Caching implementation throw an exception, the exception is wrapped and re-thrown when a call toEntryProcessorResult.get()is made.An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same. Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- keys- The set of keys for entries to process.
- entryProcessor- The- CacheEntryProcessorto invoke.
- args- Additional arguments to pass to the- CacheEntryProcessor.
- Returns:
- The map of EntryProcessorResults of the processing per key, if any, defined by theCacheEntryProcessorimplementation. No mappings will be returned forCacheEntryProcessors that return anullvalue for a key.
- Throws:
- NullPointerException- If keys or- CacheEntryProcessorare {#code null}.
- IllegalStateException- If the cache is- Cache.isClosed().
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
- See Also:
- CacheEntryProcessor
 
 - 
invokeAllAsync<T> IgniteFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args) throws TransactionException Asynchronously invokes anCacheEntryProcessoragainst the set ofCache.Entrys specified by the set of keys.If an Cache.Entrydoes not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogateCache.Entry, consisting of the key and a value of null is provided.The order that the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same CacheEntryProcessorinstance to process each entry, as the case may be in a non-local cache topology.The result of executing the CacheEntryProcessoris returned in the future as aMapofEntryProcessorResults, one result per key. Should theCacheEntryProcessoror Caching implementation throw an exception, the exception is wrapped and re-thrown when a call toEntryProcessorResult.get()is made.An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same. Keys are locked in the order in which they appear in key set. It is caller's responsibility to make sure keys always follow same order, such as by using TreeSet. Using unordered map, such asHashSet, while calling this method in parallel will lead to deadlock.- Type Parameters:
- T- Type of the cache entry processing result.
- Parameters:
- keys- The set of keys for entries to process.
- entryProcessor- The- CacheEntryProcessorto invoke.
- args- Additional arguments to pass to the- CacheEntryProcessor.
- Returns:
- a Future representing pending completion of the operation.
- Throws:
- NullPointerException- If keys or- CacheEntryProcessorare {#code null}.
- IllegalStateException- If the cache is- Cache.isClosed().
- ClassCastException- If the implementation is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the- Cache.
- TransactionException- If operation within transaction is failed.
- See Also:
- CacheEntryProcessor
 
 - 
closevoid close() Closes this cache instance.For local cache equivalent to destroy(). For distributed caches, if called on clients, stops client cache, if called on a server node, just closes this cache instance and does not destroy cache data.After cache instance is closed another IgniteCacheinstance for the same cache can be created usingIgnite.cache(String)method.
 - 
destroyvoid destroy() Completely deletes the cache with all its data from the system on all cluster nodes.
 - 
rebalance@Deprecated IgniteFuture<Boolean> rebalance() Deprecated.Use baseline topology feature instead. Please, be aware this API will be removed in the next releases.This cache node to re-balance its partitions. This method is usually used whenCacheConfiguration.getRebalanceDelay()configuration parameter has non-zero value. When many nodes are started or stopped almost concurrently, it is more efficient to delay rebalancing until the node topology is stable to make sure that no redundant re-partitioning happens.In case of CacheMode.PARTITIONEDcaches, for better efficiency user should usually make sure that new nodes get placed on the same place of consistent hash ring as the left nodes, and that nodes are restarted beforerebalanceDelayexpires. To place nodes on the same place in consistent hash ring, useIgniteConfiguration.setConsistentId(Serializable)to make sure that a node maps to the same hash ID if re-started.See CacheConfiguration.getRebalanceDelay()for more information on how to configure rebalance re-partition delay.- Returns:
- Future that will be completed when rebalancing is finished. Future.get() returns truewhen rebalance was successfully finished.
 
 - 
indexReadyFutureIgniteFuture<?> indexReadyFuture() Returns future that will be completed when all indexes for this cache are ready to use.- Returns:
- Future.
 
 - 
metricsCacheMetrics metrics() Gets whole cluster snapshot metrics (statistics) for this cache.- Returns:
- Cache metrics.
 
 - 
metricsCacheMetrics metrics(ClusterGroup grp) Gets cluster group snapshot metrics for caches in cluster group.- Parameters:
- grp- Cluster group.
- Returns:
- Cache metrics.
 
 - 
localMetricsCacheMetrics localMetrics() Gets local snapshot metrics (statistics) for this cache.- Returns:
- Cache metrics.
 
 - 
lostPartitionsCollection<Integer> lostPartitions() Gets a collection of lost partition IDs. This method provides a facility for fine-tuned handling of lost partitions. Once all lost partitions are considered recovered (for example, after the previously failed primary and backup nodes, that stored partition data in Ignite persistence, are booted)Ignite.resetLostPartitions(Collection)can used in order to clearlostflag making all partitions fully operational.- Returns:
- Lost partitions.
- See Also:
- PartitionLossPolicy,- EventType.EVT_CACHE_REBALANCE_PART_DATA_LOST,- Ignite.resetLostPartitions(Collection)
 
 - 
enableStatisticsvoid enableStatistics(boolean enabled) Sets statistics enabled flag cluster wide for this cache.- Parameters:
- enabled- Statistics enabled flag.
 
 - 
clearStatisticsvoid clearStatistics() Clear cluster statistics for this cache.
 - 
preloadPartitionvoid preloadPartition(int partition) Efficiently preloads cache primary partition into page memory.This is useful for fast iteration over cache partition data if persistence is enabled and the data is "cold". Preload will reduce available amount of page memory for subsequent operations and may lead to earlier page replacement. This method is irrelevant for in-memory caches. Calling this method on an in-memory cache will result in exception. - Parameters:
- partition- Partition.
 
 - 
preloadPartitionAsyncIgniteFuture<Void> preloadPartitionAsync(int partition) Efficiently preloads cache partition into page memory.This is useful for fast iteration over cache partition data if persistence is enabled and the data is "cold". Preload will reduce available amount of page memory for subsequent operations and may lead to earlier page replacement. This method is irrelevant for in-memory caches. Calling this method on an in-memory cache will result in exception. - Parameters:
- partition- Partition.
- Returns:
- A future representing pending completion of the partition preloading.
 
 - 
localPreloadPartitionboolean localPreloadPartition(int partition) Efficiently preloads cache partition into page memory if it exists on the local node.This is useful for fast iteration over cache partition data if persistence is enabled and the data is "cold". Preload will reduce available amount of page memory for subsequent operations and may lead to earlier page replacement. This method is irrelevant for in-memory caches. Calling this method on an in-memory cache will result in exception. - Parameters:
- partition- Partition.
- Returns:
- Trueif partition was preloaded,- falseif it doesn't belong to local node.
 
 
- 
 
-