Package org.apache.hadoop.hbase.regionserver.wal

Class FSHLog.SafePointZigZagLatch

java.lang.Object

org.apache.hadoop.hbase.regionserver.wal.FSHLog.SafePointZigZagLatch

Enclosing class:

FSHLog

static class FSHLog.SafePointZigZagLatch
extends Object

This class is used coordinating two threads holding one thread at a 'safe point' while the orchestrating thread does some work that requires the first thread paused: e.g. holding the WAL writer while its WAL is swapped out from under it by another thread.

Thread A signals Thread B to hold when it gets to a 'safe point'. Thread A wait until Thread B gets there. When the 'safe point' has been attained, Thread B signals Thread A. Thread B then holds at the 'safe point'. Thread A on notification that Thread B is paused, goes ahead and does the work it needs to do while Thread B is holding. When Thread A is done, it flags B and then Thread A and Thread B continue along on their merry way. Pause and signalling 'zigzags' between the two participating threads. We use two latches -- one the inverse of the other -- pausing and signaling when states are achieved.

To start up the drama, Thread A creates an instance of this class each time it would do this zigzag dance and passes it to Thread B (these classes use Latches so it is one shot only). Thread B notices the new instance (via reading a volatile reference or how ever) and it starts to work toward the 'safe point'. Thread A calls waitSafePoint(SyncFuture) when it cannot proceed until the Thread B 'safe point' is attained. Thread A will be held inside in waitSafePoint(SyncFuture) until Thread B reaches the 'safe point'. Once there, Thread B frees Thread A by calling safePointAttained(). Thread A now knows Thread B is at the 'safe point' and that it is holding there (When Thread B calls safePointAttained() it blocks here until Thread A calls releaseSafePoint()). Thread A proceeds to do what it needs to do while Thread B is paused. When finished, it lets Thread B lose by calling releaseSafePoint() and away go both Threads again.

Field Summary

Fields

Modifier and Type	Field	Description
private CountDownLatch	safePointAttainedLatch	Count down this latch when safe point attained.
private CountDownLatch	safePointReleasedLatch	Latch to wait on.

Constructor Summary

Constructors

Constructor	Description
SafePointZigZagLatch()

Method Summary

Modifier and Type	Method	Description
private void	checkIfSyncFailed(SyncFuture syncFuture)
(package private) boolean	isCocked()	Returns True is this is a 'cocked', fresh instance, and not one that has already fired.
(package private) boolean	isSafePointAttained()	Returns if the safepoint has been attained.
(package private) void	releaseSafePoint()	Called by Thread A when it is done with the work it needs to do while Thread B is halted.
(package private) void	safePointAttained()	Called by Thread B when it attains the 'safe point'.
(package private) SyncFuture	waitSafePoint(SyncFuture syncFuture)	For Thread A to call when it is ready to wait on the 'safe point' to be attained.

Methods inherited from class java.lang.Object

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

Field Details

safePointAttainedLatch

private volatile CountDownLatch safePointAttainedLatch

Count down this latch when safe point attained.

safePointReleasedLatch

private volatile CountDownLatch safePointReleasedLatch

Latch to wait on. Will be released when we can proceed.

Constructor Details

SafePointZigZagLatch

SafePointZigZagLatch()

Method Details

checkIfSyncFailed

private void checkIfSyncFailed(SyncFuture syncFuture)
                        throws FailedSyncBeforeLogCloseException

Throws:

FailedSyncBeforeLogCloseException

waitSafePoint

SyncFuture waitSafePoint(SyncFuture syncFuture)
                  throws InterruptedException,
FailedSyncBeforeLogCloseException

For Thread A to call when it is ready to wait on the 'safe point' to be attained. Thread A will be held in here until Thread B calls safePointAttained()

Parameters:

syncFuture - We need this as barometer on outstanding syncs. If it comes home with an exception, then something is up w/ our syncing.

Returns:

The passed syncFuture

Throws:

InterruptedException

FailedSyncBeforeLogCloseException

isSafePointAttained

@Private
boolean isSafePointAttained()

Returns if the safepoint has been attained.

safePointAttained

void safePointAttained()
                throws InterruptedException

Called by Thread B when it attains the 'safe point'. In this method, Thread B signals Thread A it can proceed. Thread B will be held in here until releaseSafePoint() is called by Thread A.

Throws:

InterruptedException

releaseSafePoint

void releaseSafePoint()

Called by Thread A when it is done with the work it needs to do while Thread B is halted. This will release the Thread B held in a call to safePointAttained()

isCocked

boolean isCocked()

Returns True is this is a 'cocked', fresh instance, and not one that has already fired.