Package org.apache.hadoop.hbase.master.assignment

Class RegionStateNodeLock

java.lang.Object

org.apache.hadoop.hbase.master.assignment.RegionStateNodeLock

@Private
class RegionStateNodeLock
extends Object

A lock implementation which supports unlock by another thread.

This is because we need to hold region state node lock while updating region state to meta(for keeping consistency), so it is better to yield the procedure to release the procedure worker. But after waking up the procedure, we may use another procedure worker to execute the procedure, which means we need to unlock by another thread.

For locking by procedure, we will also suspend the procedure if the lock is not ready, and schedule it again when lock is ready. This is very important to not block the PEWorker as we may hold the lock when updating meta, which could take a lot of time.

Please see HBASE-28196 for more details.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static interface	RegionStateNodeLock.QueueEntry	This is for abstraction the common lock/unlock logic for both Thread and Procedure.

Field Summary

Fields

Modifier and Type	Field	Description
private int	count
private final Lock	lock
private Object	owner
private final RegionInfo	regionInfo
private final Queue<RegionStateNodeLock.QueueEntry>	waitingQueue

Constructor Summary

Constructors

Constructor	Description
RegionStateNodeLock(RegionInfo regionInfo)

Method Summary

Modifier and Type	Method	Description
(package private) boolean	isLocked()	Check whether the lock is locked by someone.
(package private) boolean	isLockedBy(Object lockBy)	Check whether the lock is locked by the given lockBy.
(package private) void	lock()	Normal lock, will set the current thread as owner.
(package private) void	lock(Procedure<?> proc, Runnable wakeUp)	Lock by a procedure.
private void	lock0(RegionStateNodeLock.QueueEntry entry)
(package private) boolean	tryLock()	Normal tryLock, will set the current thread as owner.
(package private) boolean	tryLock(Procedure<?> proc)	TryLock by a procedure.
private boolean	tryLock0(Object lockBy)
(package private) void	unlock()	Normal unLock, will use the current thread as owner.
(package private) void	unlock(Procedure<?> proc)	Unlock by a procedure.
private void	unlock0(Object unlockBy)

Methods inherited from class java.lang.Object

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

Field Details

regionInfo

private final RegionInfo regionInfo

lock

private final Lock lock

waitingQueue

private final Queue<RegionStateNodeLock.QueueEntry> waitingQueue

owner

private Object owner

count

private int count

Constructor Details

RegionStateNodeLock

RegionStateNodeLock(RegionInfo regionInfo)

Method Details

lock0

private void lock0(RegionStateNodeLock.QueueEntry entry)
            throws ProcedureSuspendedException

Throws:

ProcedureSuspendedException

tryLock0

private boolean tryLock0(Object lockBy)

unlock0

private void unlock0(Object unlockBy)

lock

void lock()

Normal lock, will set the current thread as owner. Typically you should use try...finally to call unlock in the finally block.

tryLock

boolean tryLock()

Normal tryLock, will set the current thread as owner. Typically you should use try...finally to call unlock in the finally block.

unlock

void unlock()

Normal unLock, will use the current thread as owner. Typically you should use try...finally to call unlock in the finally block.

lock

void lock(Procedure<?> proc,
 Runnable wakeUp)
   throws ProcedureSuspendedException

Lock by a procedure. You can release the lock in another thread.

When the procedure can not get the lock immediately, a ProcedureSuspendedException will be thrown to suspend the procedure. And when we want to wake up a procedure, we will call the wakeUp action. Usually in the wakeUp action you should add the procedure back to procedure scheduler.

Throws:

ProcedureSuspendedException

tryLock

boolean tryLock(Procedure<?> proc)

TryLock by a procedure. You can release the lock in another thread.

unlock

void unlock(Procedure<?> proc)

Unlock by a procedure. You do not need to call this method in the same thread with lock.

isLocked

boolean isLocked()

Check whether the lock is locked by someone.

isLockedBy

boolean isLockedBy(Object lockBy)

Check whether the lock is locked by the given lockBy.