org.apache.hadoop.hbase.regionserver.snapshot

Class RegionServerSnapshotManager.SnapshotSubprocedurePool

java.lang.Object

org.apache.hadoop.hbase.regionserver.snapshot.RegionServerSnapshotManager.SnapshotSubprocedurePool

Enclosing class:

RegionServerSnapshotManager

static class RegionServerSnapshotManager.SnapshotSubprocedurePool
extends Object

We use the SnapshotSubprocedurePool, a class specific thread pool instead of ExecutorService. It uses a ExecutorCompletionService which provides queuing of completed tasks which lets us efficiently cancel pending tasks upon the earliest operation failures. HBase's ExecutorService (different from ExecutorService) isn't really built for coordinated tasks where multiple threads as part of one larger task. In RS's the HBase Executor services are only used for open and close and not other threadpooled operations such as compactions and replication sinks.

Field Summary

Fields

Modifier and Type	Field and Description
private Abortable	abortable
private ThreadPoolExecutor	executor
private List<Future<Void>>	futures
private String	name
private boolean	stopped
private ExecutorCompletionService<Void>	taskPool

Constructor Summary

Constructors

Constructor and Description
SnapshotSubprocedurePool(String name, org.apache.hadoop.conf.Configuration conf, Abortable abortable)

Method Summary

Modifier and Type	Method and Description
(package private) void	cancelTasks() This attempts to cancel out all pending and in progress tasks (interruptions issues) n
(package private) boolean	hasTasks()
(package private) void	stop() Abruptly shutdown the thread pool.
(package private) void	submitTask(Callable<Void> task) Submit a task to the pool.
(package private) boolean	waitForOutstandingTasks() Wait for all of the currently outstanding tasks submitted via submitTask(Callable).

Methods inherited from class java.lang.Object

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

Field Detail

abortable

private final Abortable abortable

taskPool

private final ExecutorCompletionService<Void> taskPool

executor

private final ThreadPoolExecutor executor

stopped

private volatile boolean stopped

futures

private final List<Future<Void>> futures

name

private final String name

Constructor Detail

SnapshotSubprocedurePool

SnapshotSubprocedurePool(String name,
                         org.apache.hadoop.conf.Configuration conf,
                         Abortable abortable)

Method Detail

hasTasks

boolean hasTasks()

submitTask

void submitTask(Callable<Void> task)

Submit a task to the pool. NOTE: all must be submitted before you can safely waitForOutstandingTasks(). This version does not support issuing tasks from multiple concurrent table snapshots requests.

waitForOutstandingTasks

boolean waitForOutstandingTasks()
                         throws ForeignException,
                                InterruptedException

Wait for all of the currently outstanding tasks submitted via submitTask(Callable). This *must* be called after all tasks are submitted via submitTask.

Returns:

true on success, false otherwise n * @throws SnapshotCreationException if the snapshot failed while we were waiting

Throws:

ForeignException

InterruptedException

cancelTasks

void cancelTasks()
          throws InterruptedException

This attempts to cancel out all pending and in progress tasks (interruptions issues) n

Throws:

InterruptedException

stop

void stop()

Abruptly shutdown the thread pool. Call when exiting a region server.