org.apache.ignite.internal.processors.cache.local

Class GridLocalCache<K,V>

java.lang.Object

org.apache.ignite.internal.processors.cache.GridCacheAdapter<K,V>

org.apache.ignite.internal.processors.cache.local.GridLocalCache<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<javax.cache.Cache.Entry<K,V>>, IgniteInternalCache<K,V>

public class GridLocalCache<K,V>
extends GridCacheAdapter<K,V>

Local cache implementation.

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

GridCacheAdapter.AsyncOp<T>, GridCacheAdapter.CacheExpiryPolicy, GridCacheAdapter.FutureHolder, GridCacheAdapter.TopologyVersionAwareJob, GridCacheAdapter.UpdateGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutAndGetTimeStatClosure<T>, GridCacheAdapter.UpdatePutTimeStatClosure<T>, GridCacheAdapter.UpdateRemoveTimeStatClosure<T>, GridCacheAdapter.UpdateTimeStatClosure<T>

Field Summary

Fields inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

cacheCfg, CLEAR_ALL_SPLIT_THRESHOLD, ctx, gridCfg, keyCheck, lastFut, locNodeId, log, map, metrics, mxBean, RET2NULL

Constructor Summary

Constructors

Constructor and Description
GridLocalCache() Empty constructor required by Externalizable.
GridLocalCache(GridCacheContext<K,V> ctx)

Method Summary

Methods

Modifier and Type	Method and Description
protected void	init() Post constructor initialization for subclasses.
boolean	isLocal()
IgniteInternalFuture<Boolean>	lockAllAsync(Collection<? extends K> keys, long timeout) All or nothing synchronous lock for passed in keys.
IgniteInternalFuture<Boolean>	lockAllAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, CacheEntryPredicate[] filter)
void	onDeferredDelete(GridCacheEntryEx entry, GridCacheVersion ver)
GridCachePreloader<K,V>	preloader()
void	removeAll() Removes mappings from cache for entries for which the optionally passed in filters do pass.
IgniteInternalFuture<?>	removeAllAsync()
IgniteInternalFuture<Boolean>	txLockAsync(Collection<KeyCacheObject> keys, long timeout, IgniteTxLocalEx tx, boolean isRead, boolean retval, TransactionIsolation isolation, boolean invalidate, long accessTtl)
void	unlockAll(Collection<? extends K> keys) Unlocks given keys only if current thread owns the locks.

Methods inherited from class org.apache.ignite.internal.processors.cache.GridCacheAdapter

affinity, allEntries, asyncOp, asyncOpAcquire, asyncOpRelease, awaitLastFut, cache, checkJta, clear, clear, clearAll, clearAsync, clearAsync, clearAsync, clearLocally, clearLocally, clearLocally, clearLocally0, clearLocally0, clearLocallyAll, commitTxAsync, configuration, containsKey, containsKeyAsync, containsKeys, containsKeysAsync, context, entries, entryEx, entryEx, entryEx, entryEx, entryExSafe, entrySet, entrySet, entrySet, entrySetx, evict, evictAll, expiry, expiryPolicy, forSubjectId, get, get, getAll, getAll, getAllAsync, getAllAsync, getAllAsync, getAllAsync, getAllAsync0, getAllOutTx, getAndPut, getAndPut, getAndPutAsync, getAndPutAsync, getAndPutAsync0, getAndPutIfAbsent, getAndPutIfAbsentAsync, getAndRemove, getAndRemoveAsync, getAndReplace, getAndReplaceAsync, getAsync, getAsync, getForcePrimary, getForcePrimaryAsync, igfsDataSpaceMax, igfsDataSpaceUsed, igniteIterator, invoke, invokeAll, invokeAll, invokeAllAsync, invokeAllAsync, invokeAsync, isColocated, isDht, isDhtAtomic, isEmpty, isIgfsDataCache, isLocked, isLockedByThread, isMongoDataCache, isMongoMetaCache, isNear, iterator, iterator, keepPortable, keySet, keySet, loadAll, localEntries, localLoad, localLoadCache, localLoadCacheAsync, localPeek, localRemoveAll, localSize, lock, lockAll, lockAsync, log, map, metrics, metrics0, mxBean, name, nearSize, offHeapAllocatedSize, offHeapEntriesCount, offHeapIterator, onIgfsDataSizeChanged, onKernalStart, onKernalStop, onUndeploy, overflowSize, peekEx, peekEx, primaryEntrySet, primaryKeySet, primaryKeySet, primarySize, printMemoryStats, promote, promoteAll, put, put, putAll, putAllAsync, putAllConflict, putAllConflictAsync, putAsync, putAsync, putAsync0, putIfAbsent, putIfAbsentAsync, randomEntry, readExternal, readResolve, readThroughAllAsync, rebalance, reloadAllAsync0, remove, remove, removeAll, removeAllAsync, removeAllConflict, removeAllConflictAsync, removeAsync, removeAsync, removeAsync, removeEntry, removeIfObsolete, removex, removexAsync, replace, replace, replaceAsync, replaceAsync, replacex, replacexAsync, saveFuture, setSkipStore, size, size, sizeAsync, skipStore, splitClearLocally, start, startInfo, stop, stopInfo, swapIterator, swapKeys, swapSize, toString, tryPutIfAbsent, tx, txStart, txStart, txStartEx, unlock, validateCacheKey, validateCacheKeys, values, values, withExpiryPolicy, writeExternal

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

GridLocalCache

public GridLocalCache()

Empty constructor required by Externalizable.

GridLocalCache

public GridLocalCache(GridCacheContext<K,V> ctx)

Parameters:

ctx - Cache registry.

Method Detail

isLocal

public boolean isLocal()

Overrides:

isLocal in class GridCacheAdapter<K,V>

Returns:

True if cache is local.

preloader

public GridCachePreloader<K,V> preloader()

Specified by:

preloader in class GridCacheAdapter<K,V>

Returns:

Preloader.

init

protected void init()

Post constructor initialization for subclasses.

Overrides:

init in class GridCacheAdapter<K,V>

txLockAsync

public IgniteInternalFuture<Boolean> txLockAsync(Collection<KeyCacheObject> keys,
                                        long timeout,
                                        IgniteTxLocalEx tx,
                                        boolean isRead,
                                        boolean retval,
                                        TransactionIsolation isolation,
                                        boolean invalidate,
                                        long accessTtl)

Specified by:

txLockAsync in class GridCacheAdapter<K,V>

Parameters:

keys - Keys to lock.

timeout - Lock timeout.

tx - Transaction.

isRead - True for read operations.

retval - Flag to return value.

isolation - Transaction isolation.

invalidate - Invalidate flag.

accessTtl - TTL for read operation.

Returns:

Locks future.

lockAllAsync

public IgniteInternalFuture<Boolean> lockAllAsync(Collection<? extends K> keys,
                                         long timeout)

All or nothing synchronous lock for passed in keys. This method together with filter check will be executed as one atomic operation. If at least one filter validation failed, no locks will be acquired.

Transactions

Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Parameters:

keys - Keys to lock.

timeout - Timeout in milliseconds to wait for lock to be acquired ('0' for no expiration).

Returns:

Future for the collection of locks. The future will return true if all filters passed and locks were acquired before timeout has expired, false otherwise.

lockAllAsync

public IgniteInternalFuture<Boolean> lockAllAsync(Collection<KeyCacheObject> keys,
                                         long timeout,
                                         @Nullable
                                         IgniteTxLocalEx tx,
                                         CacheEntryPredicate[] filter)

Parameters:

keys - Keys.

timeout - Timeout.

tx - Transaction.

filter - Filter.

Returns:

Future.

unlockAll

public void unlockAll(Collection<? extends K> keys)
               throws IgniteCheckedException

Unlocks given keys only if current thread owns the locks. Only the keys that have been locked by calling thread and pass through the filter (if any) will be unlocked. If none of the key locks is owned by current thread, then this method will do nothing.

Transactions

Locks are not transactional and should not be used from within transactions. If you do need explicit locking within transaction, then you should use TransactionConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Parameters:

keys - Keys to unlock.

Throws:

IgniteCheckedException - If unlock execution resulted in error.

removeAll

public void removeAll()
               throws IgniteCheckedException

Removes mappings from cache for entries for which the optionally passed in filters do pass. If passed in filters are null, then all entries in cache will be enrolled into transaction.

USE WITH CARE - if your cache has many entries that pass through the filter or if filter is empty, then transaction will quickly become very heavy and slow. Also, locks are acquired in undefined order, so it may cause a deadlock when used with other concurrent transactional updates.

If write-through is enabled, the values will be removed from CacheStore via @link CacheStore#removeAll(Transaction, Collection) method.

Transactions

This method is transactional and will enlist the entry into ongoing transaction if there is one.

Throws:

IgniteCheckedException - If remove failed.

removeAllAsync

public IgniteInternalFuture<?> removeAllAsync()

Returns:

Remove future.

onDeferredDelete

public void onDeferredDelete(GridCacheEntryEx entry,
                    GridCacheVersion ver)

Specified by:

onDeferredDelete in class GridCacheAdapter<K,V>

Parameters:

entry - Entry.

ver - Version.