org.gridgain.grid.kernal.processors.cache.distributed.dht.colocated

Class GridDhtColocatedCache<K,V>

java.lang.Object

org.gridgain.grid.util.lang.GridMetadataAwareAdapter

org.gridgain.grid.kernal.processors.cache.GridCacheAdapter<K,V>

org.gridgain.grid.kernal.processors.cache.distributed.GridDistributedCacheAdapter<K,V>

org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtCacheAdapter<K,V>

org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter<K,V>

org.gridgain.grid.kernal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Iterable<GridCacheEntry<K,V>>, GridCache<K,V>, GridCacheProjection<K,V>, GridMetadataAware, GridCacheProjectionEx<K,V>

public class GridDhtColocatedCache<K,V>
extends GridDhtTransactionalCacheAdapter<K,V>

Colocated cache.

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtCacheAdapter

GridDhtCacheAdapter.GridSubjectIdAddedMessageConverter616

Nested classes/interfaces inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

GridCacheAdapter.AsyncOp<T>, GridCacheAdapter.FutureHolder

Field Summary

Fields inherited from class org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtCacheAdapter

preldr, SUBJECT_ID_EVENTS_SINCE_VER

Fields inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

afterPessimisticUnlock, beforePessimisticLock, cacheCfg, CLEAR_ALL_SPLIT_THRESHOLD, ctx, gridCfg, lastFut, locNodeId, log, map, metrics

Constructor Summary

Constructors

Constructor and Description
GridDhtColocatedCache() Empty constructor required for Externalizable
GridDhtColocatedCache(GridCacheContext<K,V> ctx)
GridDhtColocatedCache(GridCacheContext<K,V> ctx, GridCacheConcurrentMap<K,V> map) Creates colocated cache with specified map.

Method Summary

Methods

Modifier and Type	Method and Description
boolean	containsKey(K key, GridPredicate<GridCacheEntry<K,V>> filter)
GridCacheEntry<K,V>	entry(K key) Gets entry from cache with the specified key.
protected GridCacheEntryEx<K,V>	entryExSafe(K key, long topVer)
GridFuture<Map<K,V>>	getAllAsync(Collection<? extends K> keys, boolean forcePrimary, boolean skipTx, GridCacheEntryEx<K,V> entry, UUID subjId, GridPredicate<GridCacheEntry<K,V>>[] filter) This method is used internally.
protected void	init() Post constructor initialization for subclasses.
boolean	isColocated()
boolean	isLocked(K key) Checks if any node owns a lock for this key.
boolean	isLockedByThread(K key) Checks if current thread owns a lock on this key.
GridFuture<Map<K,V>>	loadAsync(Collection<? extends K> keys, boolean reload, boolean forcePrimary, long topVer, UUID subjId, GridPredicate<GridCacheEntry<K,V>>[] filter)
GridFuture<Boolean>	lockAllAsync(Collection<? extends K> keys, long timeout, GridCacheTxLocalEx<K,V> tx, boolean isInvalidate, boolean isRead, boolean retval, GridCacheTxIsolation isolation, GridPredicate<GridCacheEntry<K,V>>[] filter) This is an entry point to pessimistic locking within transaction.
GridNearTransactionalCache<K,V>	near()
GridCacheTxLocalAdapter<K,V>	newTx(boolean implicit, boolean implicitSingle, GridCacheTxConcurrency concurrency, GridCacheTxIsolation isolation, long timeout, boolean invalidate, boolean syncCommit, boolean syncRollback, boolean swapOrOffheapEnabled, boolean storeEnabled, int txSize, Object grpLockKey, boolean partLock)
V	peek(K key, Collection<GridCachePeekMode> modes) Peeks at cached value using optional set of peek modes.
GridFuture<GridCacheTxEx<K,V>>	prepareTxLocally(GridDhtColocatedTxLocal<K,V> tx, Collection<GridCacheTxEntry<K,V>> reads, Collection<GridCacheTxEntry<K,V>> writes, Map<UUID,Collection<UUID>> txNodes, boolean last, Collection<UUID> lastBackups)
void	removeLocks(long threadId, GridCacheVersion ver, Collection<? extends K> keys) Removes locks regardless of whether they are owned or not for given version and keys.
void	start() Starts this cache.
void	unlockAll(Collection<? extends K> keys, GridPredicate<GridCacheEntry<K,V>>[] filter) Unlocks given keys only if current thread owns the locks.

Methods inherited from class org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter

commitTx, dgc, dgc, finish, lockAllAsync, lockAllAsyncInternal, prepareTx, processDhtLockRequest, processDhtLockRequest0, processDhtTxFinishRequest, processDhtTxFinishRequest0, processDhtTxPrepareRequest, processDhtUnlockRequest, removeLocks, rollbackTx, sendReply

Methods inherited from class org.gridgain.grid.kernal.processors.cache.distributed.dht.GridDhtCacheAdapter

beginMultiUpdate, dhtPreloader, endMultiUpdate, entryEx, entryEx, entryExx, entryExx, entryExx, entrySet, getDhtAsync, loadCache, multiUpdateFinishFuture, multiUpdateTopologyFuture, onDeferredDelete, onKernalStart, onKernalStop, peekExx, preloader, primarySize, printMemoryStats, processNearGetRequest, reload, splitClearAll, stop, topology, toString

Methods inherited from class org.gridgain.grid.kernal.processors.cache.distributed.GridDistributedCacheAdapter

lockAllAsync, removeVersionedEntry, txLockAsync

Methods inherited from class org.gridgain.grid.kernal.processors.cache.GridCacheAdapter

affinity, afterPessimisticUnlock, afterPessimisticUnlock, allEntries, asyncOp, asyncOpAcquire, asyncOpRelease, beforePessimisticLock, beforePessimisticLock, cache, checkJta, clear, clear0, clearAll, clearAll, clearAll0, compact, compact, compactAll, compactAll, configuration, containsAllKeys, containsAllValues, containsAnyKeys, containsAnyValues, containsKey, containsValue, containsValue, context, dataStructures, drBackupQueueSize, drListStateTransfers, drPause, drPauseState, drResume, drStateTransfer, entries, entryEx, entrySet, entrySet, entrySet, entrySetx, evict, evict, evictAll, evictAll, evictAll, flags, flagsOff, flagsOn, forAll, forceRepartition, forEach, forSubjectId, get, get, get, getAll, getAll, getAllAsync, getAllAsync, getAllAsync, getAllOutTx, getAllOutTxAsync, getAsync, getAsync, getForcePrimary, getForcePrimaryAsync, ggfsDataSpaceMax, ggfsDataSpaceUsed, globalClearAll, gridProjection, isDht, isDhtAtomic, isDrSystemCache, isEmpty, isGgfsDataCache, isLocal, isMongoDataCache, isMongoMetaCache, isNear, iterator, keySet, keySet, loadCacheAsync, lock, lockAll, lockAsync, log, map, metrics, metrics0, name, nearSize, offHeapAllocatedSize, offHeapEntriesCount, offHeapIterator, onGgfsDataSizeChanged, onUndeploy, overflowSize, peek, peek, peek0, peek0, peek0, peekAll, peekAll0, peekAll0, peekEx, predicate, primaryEntrySet, primaryEntrySet, primaryKeySet, primaryKeySet, primaryValues, primaryValues, processCheckCommittedTxRequest, processCheckCommittedTxResponse, processCheckPreparedTxRequest, processCheckPreparedTxResponse, projection, projection, projection, promote, promoteAll, put, put, putAll, putAllAsync, putAllDr, putAllDrAsync, putAsync, putAsync, putIfAbsent, putIfAbsentAsync, putx, putx, putxAsync, putxAsync, putxIfAbsent, putxIfAbsentAsync, queries, randomEntry, readExternal, readResolve, readThroughAllAsync, reload, reloadAll, reloadAll, reloadAll, reloadAll, reloadAll, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAllAsync, reloadAsync, reloadAsync, remove, remove, remove, removeAll, removeAll, removeAllAsync, removeAllAsync, removeAllDr, removeAllDrAsync, removeAsync, removeAsync, removeAsync, removeEntry, removeIfObsolete, removex, removex, removex, removexAsync, removexAsync, removexAsync, replace, replace, replaceAsync, replaceAsync, replacex, replacex, replacexAsync, replacexAsync, resetMetrics, saveFuture, size, startInfo, stopInfo, swapIterator, swapKeys, swapSize, toMap, transform, transformAll, transformAll, transformAllAsync, transformAllAsync, transformAndCompute, transformAsync, transformAsync, tx, txStart, txStart, txStart, txStartAffinity, txStartPartition, txSynchronizations, txSynchronize, txUnsynchronize, unlock, values, values, wrappers, writeExternal

Methods inherited from class org.gridgain.grid.util.lang.GridMetadataAwareAdapter

addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, clone, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, readExternalMeta, removeMeta, removeMeta, replaceMeta, writeExternalMeta

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.gridgain.grid.GridMetadataAware

addMeta, addMetaIfAbsent, addMetaIfAbsent, allMeta, copyMeta, copyMeta, hasMeta, hasMeta, meta, putMetaIfAbsent, putMetaIfAbsent, removeMeta, removeMeta, replaceMeta

Constructor Detail

GridDhtColocatedCache

public GridDhtColocatedCache()

Empty constructor required for Externalizable

GridDhtColocatedCache

public GridDhtColocatedCache(GridCacheContext<K,V> ctx)

Parameters:

ctx - Cache context.

GridDhtColocatedCache

public GridDhtColocatedCache(GridCacheContext<K,V> ctx,
                     GridCacheConcurrentMap<K,V> map)

Creates colocated cache with specified map.

Parameters:

ctx - Cache context.

map - Cache map.

Method Detail

isColocated

public boolean isColocated()

Overrides:

isColocated in class GridCacheAdapter<K,V>

Returns:

True if cache is colocated.

newTx

public GridCacheTxLocalAdapter<K,V> newTx(boolean implicit,
                                 boolean implicitSingle,
                                 GridCacheTxConcurrency concurrency,
                                 GridCacheTxIsolation isolation,
                                 long timeout,
                                 boolean invalidate,
                                 boolean syncCommit,
                                 boolean syncRollback,
                                 boolean swapOrOffheapEnabled,
                                 boolean storeEnabled,
                                 int txSize,
                                 @Nullable
                                 Object grpLockKey,
                                 boolean partLock)

Overrides:

newTx in class GridDhtCacheAdapter<K,V>

Parameters:

implicit - True if transaction is implicit.

implicitSingle - Implicit-with-single-key flag.

concurrency - Concurrency.

isolation - Isolation.

timeout - transaction timeout.

invalidate - Invalidation flag.

syncCommit - Synchronous commit flag.

syncRollback - Synchronous rollback flag.

swapOrOffheapEnabled - If true then swap storage will be used.

storeEnabled - if true then read/write through will be used.

txSize - Expected transaction size.

grpLockKey - Group lock key if this is a group-lock transaction.

partLock - True if partition is locked.

Returns:

New transaction.

init

protected void init()

Post constructor initialization for subclasses.

Overrides:

init in class GridDhtCacheAdapter<K,V>

start

public void start()
           throws GridException

Starts this cache. Child classes should override this method to provide custom start-up behavior.

Overrides:

start in class GridDhtTransactionalCacheAdapter<K,V>

Throws:

GridException - If start failed.

peek

public V peek(K key,
     @Nullable
     Collection<GridCachePeekMode> modes)
       throws GridException

Peeks at cached value using optional set of peek modes. This method will sequentially iterate over given peek modes in the order passed in, and try to peek at value using each peek mode. Once a non-null value is found, it will be immediately returned.

Note that if modes are not provided this method works exactly the same way as GridCacheProjection.peek(Object), implicitly using GridCachePeekMode.SMART mode.

Transactions

This method does not participate in any transactions, however, it may peek at transactional value depending on the peek modes used.

Specified by:

peek in interface GridCacheProjection<K,V>

Overrides:

peek in class GridCacheAdapter<K,V>

Parameters:

key - Entry key.

modes - Optional set of peek modes.

Returns:

Peeked value.

Throws:

GridException - If peek operation failed.

isLocked

public boolean isLocked(K key)

Checks if any node owns a lock for this key.

This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.

Specified by:

isLocked in interface GridCacheProjection<K,V>

Overrides:

isLocked in class GridCacheAdapter<K,V>

Parameters:

key - Key to check.

Returns:

True if lock is owned by some node.

isLockedByThread

public boolean isLockedByThread(K key)

Checks if current thread owns a lock on this key.

This is a local in-VM operation and does not involve any network trips or access to persistent storage in any way.

Specified by:

isLockedByThread in interface GridCacheProjection<K,V>

Overrides:

isLockedByThread in class GridCacheAdapter<K,V>

Parameters:

key - Key to check.

Returns:

True if key is locked by current thread.

getAllAsync

public GridFuture<Map<K,V>> getAllAsync(@Nullable
                               Collection<? extends K> keys,
                               boolean forcePrimary,
                               boolean skipTx,
                               @Nullable
                               GridCacheEntryEx<K,V> entry,
                               @Nullable
                               UUID subjId,
                               @Nullable
                               GridPredicate<GridCacheEntry<K,V>>[] filter)

This method is used internally. Use GridDhtCacheAdapter.getDhtAsync(UUID, long, LinkedHashMap, boolean, long, UUID, GridPredicate[]) method instead to retrieve DHT value.

Overrides:

getAllAsync in class GridDhtCacheAdapter<K,V>

Parameters:

keys -

forcePrimary -

skipTx -

filter -

Returns:

entryExSafe

protected GridCacheEntryEx<K,V> entryExSafe(K key,
                                long topVer)

Overrides:

entryExSafe in class GridCacheAdapter<K,V>

Parameters:

key - Key.

Returns:

Entry.

containsKey

public boolean containsKey(K key,
                  @Nullable
                  GridPredicate<GridCacheEntry<K,V>> filter)

Overrides:

containsKey in class GridCacheAdapter<K,V>

Parameters:

key - Key.

filter - Filters to evaluate.

Returns:

True if contains key.

loadAsync

public GridFuture<Map<K,V>> loadAsync(@Nullable
                             Collection<? extends K> keys,
                             boolean reload,
                             boolean forcePrimary,
                             long topVer,
                             @Nullable
                             UUID subjId,
                             @Nullable
                             GridPredicate<GridCacheEntry<K,V>>[] filter)

Parameters:

keys - Keys to load.

reload - Reload flag.

forcePrimary - Force get from primary node flag.

filter - Filter.

Returns:

Loaded values.

lockAllAsync

public GridFuture<Boolean> lockAllAsync(Collection<? extends K> keys,
                               long timeout,
                               @Nullable
                               GridCacheTxLocalEx<K,V> tx,
                               boolean isInvalidate,
                               boolean isRead,
                               boolean retval,
                               @Nullable
                               GridCacheTxIsolation isolation,
                               GridPredicate<GridCacheEntry<K,V>>[] filter)

This is an entry point to pessimistic locking within transaction.

Overrides:

lockAllAsync in class GridDhtTransactionalCacheAdapter<K,V>

Parameters:

keys - Keys to lock.

timeout - Timeout.

tx - Transaction

isInvalidate - Invalidation flag.

isRead - Indicates whether value is read or written.

retval - Flag to return value.

isolation - Transaction isolation.

filter - Optional filter.

Returns:

Future for locks.

near

public GridNearTransactionalCache<K,V> near()

Specified by:

near in class GridDhtTransactionalCacheAdapter<K,V>

Returns:

Near cache.

entry

public GridCacheEntry<K,V> entry(K key)
                          throws GridDhtInvalidPartitionException

Gets entry from cache with the specified key. The returned entry can be used even after entry key has been removed from cache. In that case, every operation on returned entry will result in creation of a new entry.

Note that this method can return null if projection is configured as pre-filtered and entry key and value don't pass key-value filter of the projection.

Specified by:

entry in interface GridCacheProjection<K,V>

Overrides:

entry in class GridDhtCacheAdapter<K,V>

Parameters:

key - Entry key.

Returns:

Cache entry or null if projection pre-filtering was not passed.

Throws:

GridDhtInvalidPartitionException - If partition for the key is no longer valid.

unlockAll

public void unlockAll(Collection<? extends K> keys,
             GridPredicate<GridCacheEntry<K,V>>[] filter)

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 GridCacheTxConcurrency.PESSIMISTIC concurrency control for transaction which will acquire explicit locks for relevant cache operations.

Cache Flags

This method is not available if any of the following flags are set on projection: GridCacheFlag.LOCAL, GridCacheFlag.READ.

Specified by:

unlockAll in interface GridCacheProjection<K,V>

Overrides:

unlockAll in class GridDhtCacheAdapter<K,V>

Parameters:

keys - Keys to unlock.

filter - Optional filter which needs to pass for individual entries to be unlocked.

removeLocks

public void removeLocks(long threadId,
               GridCacheVersion ver,
               Collection<? extends K> keys)

Removes locks regardless of whether they are owned or not for given version and keys.

Parameters:

threadId - Thread ID.

ver - Lock version.

keys - Keys.

prepareTxLocally

public GridFuture<GridCacheTxEx<K,V>> prepareTxLocally(GridDhtColocatedTxLocal<K,V> tx,
                                              Collection<GridCacheTxEntry<K,V>> reads,
                                              Collection<GridCacheTxEntry<K,V>> writes,
                                              Map<UUID,Collection<UUID>> txNodes,
                                              boolean last,
                                              Collection<UUID> lastBackups)

Parameters:

tx - Started colocated transaction to prepare.

reads - Read collection.

writes - Write collection.

txNodes - Transaction nodes mapping.

last - True if this is last prepare operation.

lastBackups - IDs of backup nodes receiving last prepare request.

Returns:

Future for transaction.