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

Class BucketCache.WriterThread

java.lang.Object

org.apache.hadoop.hbase.util.HasThread

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

All Implemented Interfaces:

Runnable

Enclosing class:

BucketCache

class BucketCache.WriterThread
extends HasThread

Field Summary

Fields

Modifier and Type	Field and Description
private BlockingQueue<BucketCache.RAMQueueEntry>	inputQueue
private boolean	writerEnabled

Constructor Summary

Constructors

Constructor and Description
WriterThread(BlockingQueue<BucketCache.RAMQueueEntry> queue)

Method Summary

Modifier and Type	Method and Description
(package private) void	disableWriter()
(package private) void	doDrain(List<BucketCache.RAMQueueEntry> entries) Flush the entries in ramCache to IOEngine and add bucket entry to backingMap.
private void	putIntoBackingMap(BlockCacheKey key, BucketCache.BucketEntry bucketEntry) Put the new bucket entry into backingMap.
void	run()

Methods inherited from class org.apache.hadoop.hbase.util.HasThread

getName, getThread, interrupt, isAlive, isInterrupted, join, join, join, setDaemon, setName, setPriority, setUncaughtExceptionHandler, start

Methods inherited from class java.lang.Object

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

Field Detail

inputQueue

private final BlockingQueue<BucketCache.RAMQueueEntry> inputQueue

writerEnabled

private volatile boolean writerEnabled

Constructor Detail

WriterThread

WriterThread(BlockingQueue<BucketCache.RAMQueueEntry> queue)

Method Detail

disableWriter

void disableWriter()

run

public void run()

Specified by:

run in interface Runnable

Specified by:

run in class HasThread

putIntoBackingMap

private void putIntoBackingMap(BlockCacheKey key,
                               BucketCache.BucketEntry bucketEntry)

Put the new bucket entry into backingMap. Notice that we are allowed to replace the existing cache with a new block for the same cache key. there's a corner case: one thread cache a block in ramCache, copy to io-engine and add a bucket entry to backingMap. Caching another new block with the same cache key do the same thing for the same cache key, so if not evict the previous bucket entry, then memory leak happen because the previous bucketEntry is gone but the bucketAllocator do not free its memory.

Parameters:

key - Block cache key

bucketEntry - Bucket entry to put into backingMap.

See Also:

BlockCacheUtil.shouldReplaceExistingCacheBlock(BlockCache blockCache,BlockCacheKey cacheKey, Cacheable newBlock)

doDrain

void doDrain(List<BucketCache.RAMQueueEntry> entries)
      throws InterruptedException

Flush the entries in ramCache to IOEngine and add bucket entry to backingMap. Process all that are passed in even if failure being sure to remove from ramCache else we'll never undo the references and we'll OOME.

Parameters:

entries - Presumes list passed in here will be processed by this invocation only. No interference expected.

Throws:

InterruptedException