IgniteCache (Ignite 1.0.0)

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>>

All Known Implementing Classes:

IgniteCacheProxy
```
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 calling Ignite.cache(String) method.
Functionality
This API extends Cache API which contains JCache (JSR107) cache functionality and documentation. In addition to Cache functionality this API provides:
- Ability to perform basic atomic Map-like operations available on JCache API.
- 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 via localPeek(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.
Transactions
Cache API supports transactions. You can group and set of cache methods within a transaction to provide ACID-compliant behavior. See IgniteTransactions for more information.
Asynchronous Mode
Cache API supports asynchronous mode via IgniteAsyncSupport functionality. To turn on asynchronous mode invoke withAsync() method. Once asynchronous mode is enabled, all methods with @IgniteAsyncSupported annotation will be executed asynchronously.

Nested Class Summary
- Nested classes/interfaces inherited from interface javax.cache.Cache
  javax.cache.Cache.Entry<K,V>

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clear()`
`void`	`clear(K key)` Clear entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`void`	`clearAll(Set<K> keys)` Clear entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`boolean`	`containsKey(K key)`
`boolean`	`containsKeys(Set<? extends K> keys)`
`V`	`get(K key)`
`Map<K,V>`	`getAll(Set<? extends K> keys)`
`V`	`getAndPut(K key, V val)`
`V`	`getAndPutIfAbsent(K key, V val)` Stores given key-value pair in cache only if cache had no previous mapping for it.
`V`	`getAndRemove(K key)`
`V`	`getAndReplace(K key, V val)`
`<C extends javax.cache.configuration.Configuration<K,V>> C`	`getConfiguration(Class<C> clazz)`
`<T> T`	`invoke(K key, CacheEntryProcessor<K,V,T> entryProcessor, Object... arguments)` Invokes an `CacheEntryProcessor` against the `Cache.Entry` specified by the provided key.
`<T> T`	`invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... arguments)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map, Object... args)`
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Set<? extends K> keys, CacheEntryProcessor<K,V,T> entryProcessor, Object... args)` Invokes an `CacheEntryProcessor` against the set of `Cache.Entry`s specified by the set of keys.
`<T> Map<K,javax.cache.processor.EntryProcessorResult<T>>`	`invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProcessor, Object... args)`
`boolean`	`isLocalLocked(K key, boolean byCurrThread)` Checks if specified key is locked.
`void`	`loadCache(IgniteBiPredicate<K,V> p, Object... args)` Executes `localLoadCache(IgniteBiPredicate, Object...)` on all cache nodes.
`void`	`localClear(K key)` Clear entry from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`void`	`localClearAll(Set<K> keys)` Clear entries from the cache and swap storage, without notifying listeners or `CacheWriter`s.
`Iterable<javax.cache.Cache.Entry<K,V>>`	`localEntries(CachePeekMode... peekModes)` Allows for iteration over local cache entries.
`void`	`localEvict(Collection<? extends K> keys)` Attempts to evict all entries associated with keys.
`void`	`localLoadCache(IgniteBiPredicate<K,V> p, Object... args)` Delegates to `CacheStore.loadCache(IgniteBiInClosure,Object...)` method to load state from the underlying persistent storage.
`V`	`localPeek(K key, CachePeekMode... peekModes)` Peeks at in-memory cached value using default optinal peek mode.
`void`	`localPromote(Set<? extends K> keys)` This method unswaps cache entries by given keys, if any, from swap storage into memory.
`int`	`localSize(CachePeekMode... peekModes)` Gets the number of all entries cached on this node.
`Lock`	`lock(K key)` Creates a `Lock` instance associated with passed key.
`Lock`	`lockAll(Collection<? extends K> keys)` Creates a `Lock` instance associated with passed keys.
`CacheMetrics`	`metrics()` Gets snapshot metrics (statistics) for this cache.
`CacheMetricsMXBean`	`mxBean()` Gets MxBean for this cache.
`void`	`put(K key, V val)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`boolean`	`putIfAbsent(K key, V val)`
`<R> QueryCursor<R>`	`query(Query<R> qry)` Queries cache.
`QueryMetrics`	`queryMetrics()` Gets query metrics.
`javax.cache.Cache.Entry<K,V>`	`randomEntry()` Gets a random entry out of cache.
`IgniteFuture<?>`	`rebalance()` This cache node to re-balance its partitions.
`boolean`	`remove(K key)`
`boolean`	`remove(K key, V oldVal)`
`void`	`removeAll()`
`void`	`removeAll(Set<? extends K> keys)`
`boolean`	`replace(K key, V val)`
`boolean`	`replace(K key, V oldVal, V newVal)`
`int`	`size(CachePeekMode... peekModes)` Gets the number of all entries cached across all nodes.
`IgniteCache<K,V>`	`withAsync()` Gets component with asynchronous mode enabled.
`IgniteCache<K,V>`	`withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)`
`IgniteCache<K,V>`	`withSkipStore()`

Methods inherited from interface javax.cache.Cache
close, deregisterCacheEntryListener, getCacheManager, getName, isClosed, iterator, loadAll, registerCacheEntryListener, unwrap

Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport
future, isAsync

- Method Detail
  - withAsync
```
IgniteCache<K,V> withAsync()
```
    Gets component with asynchronous mode enabled.
    
    Specified by:
    
    withAsync in interface IgniteAsyncSupport
    
    Returns:
    Component with asynchronous mode enabled.
  - getConfiguration
```
<C extends javax.cache.configuration.Configuration<K,V>> C getConfiguration(Class<C> clazz)
```
    Specified by:
    
    getConfiguration in interface javax.cache.Cache<K,V>
  - randomEntry
```
javax.cache.Cache.Entry<K,V> randomEntry()
```
    Gets a random entry out of cache. In the worst cache scenario this method has complexity of
```
O(S * N/64)
```
    where N is the size of internal hash table and S is the number of hash table buckets to sample, which is 5 by default. However, if the table is pretty dense, with density factor of N/64, which is true for near fully populated caches, this method will generally perform significantly faster with complexity of O(S) where S = 5.
    Returns:
    Random entry, or null if cache is empty.
  - withExpiryPolicy
```
IgniteCache<K,V> withExpiryPolicy(javax.cache.expiry.ExpiryPolicy plc)
```
  - withSkipStore
```
IgniteCache<K,V> withSkipStore()
```
    Returns:
    Cache with read-through write-through behavior disabled.
  - loadCache
```
@IgniteAsyncSupported
void loadCache(@Nullable
                                  IgniteBiPredicate<K,V> p,
                                  @Nullable
                                  Object... args)
               throws javax.cache.CacheException
```
    Executes localLoadCache(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.
  - localLoadCache
```
@IgniteAsyncSupported
void localLoadCache(@Nullable
                                       IgniteBiPredicate<K,V> p,
                                       @Nullable
                                       Object... args)
                    throws javax.cache.CacheException
```
    Delegates to CacheStore.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 returns true, will be stored in cache. If predicate is null, 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 CacheStore implementation 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.
  - getAndPutIfAbsent
```
@IgniteAsyncSupported
V getAndPutIfAbsent(K key,
                                       V val)
                    throws javax.cache.CacheException
```
    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 of CacheMode.PARTITIONED or CacheMode.REPLICATED caches, 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 CacheStore via CacheWriter.write(javax.cache.Cache.Entry) method.
    Transactions
    This 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 (null if there was no previous value).
    
    Throws:
    
    NullPointerException - If either key or value are null.
    
    javax.cache.CacheException - If put operation failed.
  - lock
```
Lock lock(K key)
```
    Creates a Lock instance associated with passed key. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not support Lock.newCondition() method, other methods defined in Lock are supported.
    
    Parameters:
    key - Key for lock.
    
    Returns:
    New lock instance associated with passed key.
    See Also:
    Lock.lock(), Lock.tryLock(long, TimeUnit)
  - lockAll
```
Lock lockAll(Collection<? extends K> keys)
```
    Creates a Lock instance associated with passed keys. This method does not acquire lock immediately, you have to call appropriate method on returned instance. Returned lock does not support Lock.newCondition() method, other methods defined in Lock are supported.
    
    Parameters:
    keys - Keys for lock.
    
    Returns:
    New lock instance associated with passed key.
    See Also:
    Lock.lock(), Lock.tryLock(long, TimeUnit)
  - isLocalLocked
```
boolean 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 true method will check that current thread owns a lock on this key, other vise will check that any thread on any node owns a lock on this key.
    
    Returns:
    True if lock is owned by some node.
  - query
```
<R> QueryCursor<R> query(Query<R> qry)
```
    Queries cache. Accepts any subclass of Query interface.
    
    Parameters:
    qry - Query.
    
    Returns:
    Cursor.
    See Also:
    ScanQuery, SqlQuery, TextQuery, SpiQuery
  - localEntries
```
Iterable<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.
  - queryMetrics
```
QueryMetrics queryMetrics()
```
    Gets query metrics.
    
    Returns:
    Metrics.
  - localEvict
```
void 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.
  - localPeek
```
V localPeek(K key,
          CachePeekMode... peekModes)
```
    Peeks at in-memory cached value using default optinal peek mode.
    This method will not load value from any persistent store or from a remote node.
    Transactions
    This method does not participate in any transactions.
    
    Parameters:
    key - Entry key.
    
    Returns:
    Peeked value, or null if not found.
    
    Throws:
    
    NullPointerException - If key is null.
  - localPromote
```
void localPromote(Set<? extends K> keys)
                  throws javax.cache.CacheException
```
    This method unswaps cache entries by given keys, if any, from swap storage into memory.
    Transactions
    This method is not transactional.
    
    Parameters:
    keys - Keys to promote entries for.
    
    Throws:
    
    javax.cache.CacheException - If promote failed.
  - size
```
@IgniteAsyncSupported
int size(CachePeekMode... peekModes)
         throws javax.cache.CacheException
```
    Gets the number of all entries cached across all nodes.
    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
  - localSize
```
int localSize(CachePeekMode... peekModes)
```
    Gets the number of all entries cached on this node.
    
    Parameters:
    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)
```
    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 the EntryProcessor implementation. No mappings will be returned for EntryProcessors that return a null value for a key.
  - get
```
@IgniteAsyncSupported
V get(K key)
```
    Specified by:
    
    get in interface javax.cache.Cache<K,V>
  - getAll
```
@IgniteAsyncSupported
Map<K,V> getAll(Set<? extends K> keys)
```
    Specified by:
    
    getAll in interface javax.cache.Cache<K,V>
  - containsKey
```
@IgniteAsyncSupported
boolean containsKey(K key)
```
    Specified by:
    
    containsKey in interface javax.cache.Cache<K,V>
  - containsKeys
```
@IgniteAsyncSupported
boolean containsKeys(Set<? extends K> keys)
```
  - put
```
@IgniteAsyncSupported
void put(K key,
                            V val)
```
    Specified by:
    
    put in interface javax.cache.Cache<K,V>
  - getAndPut
```
@IgniteAsyncSupported
V getAndPut(K key,
                               V val)
```
    Specified by:
    
    getAndPut in interface javax.cache.Cache<K,V>
  - putAll
```
@IgniteAsyncSupported
void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface javax.cache.Cache<K,V>
  - putIfAbsent
```
@IgniteAsyncSupported
boolean putIfAbsent(K key,
                                       V val)
```
    Specified by:
    
    putIfAbsent in interface javax.cache.Cache<K,V>
  - remove
```
@IgniteAsyncSupported
boolean remove(K key)
```
    Specified by:
    
    remove in interface javax.cache.Cache<K,V>
  - remove
```
@IgniteAsyncSupported
boolean remove(K key,
                                  V oldVal)
```
    Specified by:
    
    remove in interface javax.cache.Cache<K,V>
  - getAndRemove
```
@IgniteAsyncSupported
V getAndRemove(K key)
```
    Specified by:
    
    getAndRemove in interface javax.cache.Cache<K,V>
  - replace
```
@IgniteAsyncSupported
boolean replace(K key,
                                   V oldVal,
                                   V newVal)
```
    Specified by:
    
    replace in interface javax.cache.Cache<K,V>
  - replace
```
@IgniteAsyncSupported
boolean replace(K key,
                                   V val)
```
    Specified by:
    
    replace in interface javax.cache.Cache<K,V>
  - getAndReplace
```
@IgniteAsyncSupported
V getAndReplace(K key,
                                   V val)
```
    Specified by:
    
    getAndReplace in interface javax.cache.Cache<K,V>
  - removeAll
```
@IgniteAsyncSupported
void removeAll(Set<? extends K> keys)
```
    Specified by:
    
    removeAll in interface javax.cache.Cache<K,V>
  - removeAll
```
@IgniteAsyncSupported
void removeAll()
```
    Specified by:
    
    removeAll in interface javax.cache.Cache<K,V>
  - clear
```
@IgniteAsyncSupported
void clear()
```
    Specified by:
    
    clear in interface javax.cache.Cache<K,V>
  - clear
```
@IgniteAsyncSupported
void clear(K key)
```
    Clear entry from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    
    Parameters:
    key - Key to clear.
    
    Throws:
    
    IllegalStateException - if the cache is Cache.isClosed()
    
    javax.cache.CacheException - if there is a problem during the clear
  - clearAll
```
@IgniteAsyncSupported
void clearAll(Set<K> keys)
```
    Clear entries from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    
    Parameters:
    keys - Keys to clear.
    
    Throws:
    
    IllegalStateException - if the cache is Cache.isClosed()
    
    javax.cache.CacheException - if there is a problem during the clear
  - localClear
```
void localClear(K key)
```
    Clear entry from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    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.
  - localClearAll
```
void localClearAll(Set<K> keys)
```
    Clear entries from the cache and swap storage, without notifying listeners or CacheWriters. Entry is cleared only if it is not currently locked, and is not participating in a transaction.
    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)
```
    Specified by:
    
    invoke in interface javax.cache.Cache<K,V>
  - invoke
```
@IgniteAsyncSupported
<T> T invoke(K key,
                                CacheEntryProcessor<K,V,T> entryProcessor,
                                Object... arguments)
```
    Invokes an CacheEntryProcessor against the Cache.Entry specified by the provided key. If an Cache.Entry does not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogate Cache.Entry, consisting of the key with a null value is used instead. This method different
    
    Parameters:
    key - the key to the entry
    entryProcessor - the CacheEntryProcessor to invoke
    arguments - additional arguments to pass to the CacheEntryProcessor
    
    Returns:
    the result of the processing, if any, defined by the CacheEntryProcessor implementation
    
    Throws:
    
    NullPointerException - if key or CacheEntryProcessor is 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 Exception thrown wrapped in an EntryProcessorException.
    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)
```
    Specified by:
    
    invokeAll in interface javax.cache.Cache<K,V>
  - invokeAll
```
@IgniteAsyncSupported
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
                                                                                      CacheEntryProcessor<K,V,T> entryProcessor,
                                                                                      Object... args)
```
    Invokes an CacheEntryProcessor against the set of Cache.Entrys specified by the set of keys.
    If an Cache.Entry does not exist for the specified key, an attempt is made to load it (if a loader is configured) or a surrogate Cache.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 CacheEntryProcessor instance to process each entry, as the case may be in a non-local cache topology.
    The result of executing the CacheEntryProcessor is returned as a Map of EntryProcessorResults, one result per key. Should the CacheEntryProcessor or Caching implementation throw an exception, the exception is wrapped and re-thrown when a call to EntryProcessorResult.get() is made.
    
    Parameters:
    keys - the set of keys for entries to process
    entryProcessor - the CacheEntryProcessor to invoke
    args - additional arguments to pass to the CacheEntryProcessor
    
    Returns:
    the map of EntryProcessorResults of the processing per key, if any, defined by the CacheEntryProcessor implementation. No mappings will be returned for CacheEntryProcessors that return a null value for a key.
    
    Throws:
    
    NullPointerException - if keys or CacheEntryProcessor are 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
    See Also:
    CacheEntryProcessor
  - rebalance
```
IgniteFuture<?> rebalance()
```
    This cache node to re-balance its partitions. This method is usually used when CacheConfiguration.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 ofCacheMode.PARTITIONED caches, 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 before rebalanceDelay expires. To place nodes on the same place in consistent hash ring, use RendezvousAffinityFunction.setHashIdResolver(AffinityNodeHashResolver) 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.
  - metrics
```
CacheMetrics metrics()
```
    Gets snapshot metrics (statistics) for this cache.
    
    Returns:
    Cache metrics.
  - mxBean
```
CacheMetricsMXBean mxBean()
```
    Gets MxBean for this cache.
    
    Returns:
    MxBean.

Interface IgniteCache<K,V>

Functionality

Transactions

Asynchronous Mode

Nested Class Summary

Nested classes/interfaces inherited from interface javax.cache.Cache

Method Summary

Methods inherited from interface javax.cache.Cache

Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport

Method Detail

withAsync

getConfiguration

randomEntry

withExpiryPolicy

withSkipStore

loadCache

localLoadCache

getAndPutIfAbsent

Transactions

lock

lockAll

isLocalLocked

query

localEntries

queryMetrics

localEvict

localPeek

Transactions

localPromote

Transactions

size

localSize

invokeAll

get

getAll

containsKey

containsKeys

put

getAndPut

putAll

putIfAbsent

remove

remove

getAndRemove

replace

replace

getAndReplace

removeAll

removeAll

clear

clear

clearAll

localClear

localClearAll

invoke

invoke

invokeAll

invokeAll

rebalance

metrics

mxBean