org.apache.hadoop.hbase.io.hfile.bucket

Class BucketCache.RAMCache

java.lang.Object

org.apache.hadoop.hbase.io.hfile.bucket.BucketCache.RAMCache

Enclosing class:

BucketCache

static class BucketCache.RAMCache
extends Object

Wrapped the delegate ConcurrentMap with maintaining its block's reference count.

Field Summary

Fields

Modifier and Type	Field and Description
(package private) ConcurrentHashMap<BlockCacheKey,BucketCache.RAMQueueEntry>	delegate Defined the map as ConcurrentHashMap explicitly here, because in get(BlockCacheKey) and putIfAbsent(BlockCacheKey, BucketCache.RAMQueueEntry) , we need to guarantee the atomicity of map#computeIfPresent(key, func) and map#putIfAbsent(key, func).

Constructor Summary

Constructors

Constructor and Description
RAMCache()

Method Summary

Modifier and Type	Method and Description
void	clear()
boolean	containsKey(BlockCacheKey key)
BucketCache.RAMQueueEntry	get(BlockCacheKey key)
boolean	isEmpty()
BucketCache.RAMQueueEntry	putIfAbsent(BlockCacheKey key, BucketCache.RAMQueueEntry entry) Return the previous associated value, or null if absent.
boolean	remove(BlockCacheKey key)
boolean	remove(BlockCacheKey key, Consumer<BucketCache.RAMQueueEntry> action) Defined an Consumer here, because once the removed entry release its reference count, then it's ByteBuffers may be recycled and accessing it outside this method will be thrown an exception.

Methods inherited from class java.lang.Object

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

Field Detail

delegate

final ConcurrentHashMap<BlockCacheKey,BucketCache.RAMQueueEntry> delegate

Defined the map as ConcurrentHashMap explicitly here, because in get(BlockCacheKey) and putIfAbsent(BlockCacheKey, BucketCache.RAMQueueEntry) , we need to guarantee the atomicity of map#computeIfPresent(key, func) and map#putIfAbsent(key, func). Besides, the func method can execute exactly once only when the key is present(or absent) and under the lock context. Otherwise, the reference count of block will be messed up. Notice that the ConcurrentSkipListMap can not guarantee that.

Constructor Detail

RAMCache

RAMCache()

Method Detail

containsKey

public boolean containsKey(BlockCacheKey key)

get

public BucketCache.RAMQueueEntry get(BlockCacheKey key)

putIfAbsent

public BucketCache.RAMQueueEntry putIfAbsent(BlockCacheKey key,
                                             BucketCache.RAMQueueEntry entry)

Return the previous associated value, or null if absent. It has the same meaning as ConcurrentMap.putIfAbsent(Object, Object)

remove

public boolean remove(BlockCacheKey key)

remove

public boolean remove(BlockCacheKey key,
                      Consumer<BucketCache.RAMQueueEntry> action)

Defined an Consumer here, because once the removed entry release its reference count, then it's ByteBuffers may be recycled and accessing it outside this method will be thrown an exception. the consumer will access entry to remove before release its reference count. Notice, don't change its reference count in the Consumer

isEmpty

public boolean isEmpty()

clear

public void clear()