MasterProcedureScheduler (Apache HBase

java.lang.Object
- org.apache.hadoop.hbase.master.procedure.MasterProcedureScheduler

所有已实现的接口:

ProcedureRunnableSet
```
@InterfaceAudience.Private
@InterfaceStability.Evolving
public class MasterProcedureScheduler
extends Object
implements ProcedureRunnableSet
```
ProcedureRunnableSet for the Master Procedures. This RunnableSet tries to provide to the ProcedureExecutor procedures that can be executed without having to wait on a lock. Most of the master operations can be executed concurrently, if they are operating on different tables (e.g. two create table can be performed at the same, time assuming table A and table B) or against two different servers; say two servers that crashed at about the same time.
Each procedure should implement an interface providing information for this queue. for example table related procedures should implement TableProcedureInterface. each procedure will be pushed in its own queue, and based on the operation type we may take smarter decision. e.g. we can abort all the operations preceding a delete table, or similar.

嵌套类概要

嵌套类
限定符和类型	类和说明
`static class`	`MasterProcedureScheduler.ProcedureEvent`
`static class`	`MasterProcedureScheduler.ServerQueue`
`static class`	`MasterProcedureScheduler.TableQueue`

构造器概要

构造器
构造器和说明

MasterProcedureScheduler(org.apache.hadoop.conf.Configuration conf, TableLockManager lockManager)

构造器
构造器和说明
`MasterProcedureScheduler(org.apache.hadoop.conf.Configuration conf, TableLockManager lockManager)`

方法概要

方法
限定符和类型	方法和说明
`void`	`addBack(Procedure proc)`
`void`	`addFront(Procedure proc)`
`void`	`clear()`
`void`	`completionCleanup(Procedure proc)`
`long`	`getNullPollCalls()`
`long`	`getPollCalls()`
`protected boolean`	`markTableAsDeleted(TableName table)` Tries to remove the queue and the table-lock of the specified table.
`Procedure`	`poll()`
`void`	`releaseNamespaceExclusiveLock(Procedure procedure, String nsName)` Release the exclusive lock
`void`	`releaseServerExclusiveLock(Procedure procedure, ServerName serverName)` Release the exclusive lock
`void`	`releaseServerSharedLock(Procedure procedure, ServerName serverName)` Release the shared lock taken
`void`	`releaseTableExclusiveLock(Procedure procedure, TableName table)` Release the exclusive lock taken with tryAcquireTableWrite()
`void`	`releaseTableSharedLock(Procedure procedure, TableName table)` Release the shared lock taken with tryAcquireTableRead()
`void`	`signalAll()`
`int`	`size()`
`void`	`suspend(MasterProcedureScheduler.ProcedureEvent event)`
`boolean`	`tryAcquireNamespaceExclusiveLock(Procedure procedure, String nsName)` Try to acquire the exclusive lock on the specified namespace.
`boolean`	`tryAcquireServerExclusiveLock(Procedure procedure, ServerName serverName)` Try to acquire the exclusive lock on the specified server.
`boolean`	`tryAcquireServerSharedLock(Procedure procedure, ServerName serverName)` Try to acquire the shared lock on the specified server.
`boolean`	`tryAcquireTableExclusiveLock(Procedure procedure, TableName table)` Try to acquire the exclusive lock on the specified table.
`boolean`	`tryAcquireTableSharedLock(Procedure procedure, TableName table)` Try to acquire the shared lock on the specified table.
`boolean`	`waitEvent(MasterProcedureScheduler.ProcedureEvent event, Procedure procedure)`
`boolean`	`waitEvent(MasterProcedureScheduler.ProcedureEvent event, Procedure procedure, boolean suspendQueue)`
`void`	`wake(MasterProcedureScheduler.ProcedureEvent event)`
`void`	`yield(Procedure proc)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - MasterProcedureScheduler
```
public MasterProcedureScheduler(org.apache.hadoop.conf.Configuration conf,
                        TableLockManager lockManager)
```
- 方法详细资料
  - addFront
```
public void addFront(Procedure proc)
```
    指定者:
    
    addFront 在接口中 ProcedureRunnableSet
  - addBack
```
public void addBack(Procedure proc)
```
    指定者:
    
    addBack 在接口中 ProcedureRunnableSet
  - yield
```
public void yield(Procedure proc)
```
    指定者:
    
    yield 在接口中 ProcedureRunnableSet
  - poll
```
public Procedure poll()
```
    指定者:
    
    poll 在接口中 ProcedureRunnableSet
  - clear
```
public void clear()
```
    指定者:
    
    clear 在接口中 ProcedureRunnableSet
  - signalAll
```
public void signalAll()
```
    指定者:
    
    signalAll 在接口中 ProcedureRunnableSet
  - size
```
public int size()
```
    指定者:
    
    size 在接口中 ProcedureRunnableSet
  - completionCleanup
```
public void completionCleanup(Procedure proc)
```
    指定者:
    
    completionCleanup 在接口中 ProcedureRunnableSet
  - getPollCalls
```
public long getPollCalls()
```
  - getNullPollCalls
```
public long getNullPollCalls()
```
  - waitEvent
```
public boolean waitEvent(MasterProcedureScheduler.ProcedureEvent event,
                Procedure procedure)
```
  - waitEvent
```
public boolean waitEvent(MasterProcedureScheduler.ProcedureEvent event,
                Procedure procedure,
                boolean suspendQueue)
```
  - suspend
```
public void suspend(MasterProcedureScheduler.ProcedureEvent event)
```
  - wake
```
public void wake(MasterProcedureScheduler.ProcedureEvent event)
```
  - tryAcquireTableExclusiveLock
```
public boolean tryAcquireTableExclusiveLock(Procedure procedure,
                                   TableName table)
```
    Try to acquire the exclusive lock on the specified table. other operations in the table-queue will be executed after the lock is released.
    
    参数:
    procedure - the procedure trying to acquire the lock
    table - Table to lock
    
    返回:
    true if we were able to acquire the lock on the table, otherwise false.
  - releaseTableExclusiveLock
```
public void releaseTableExclusiveLock(Procedure procedure,
                             TableName table)
```
    Release the exclusive lock taken with tryAcquireTableWrite()
    
    参数:
    procedure - the procedure releasing the lock
    table - the name of the table that has the exclusive lock
  - tryAcquireTableSharedLock
```
public boolean tryAcquireTableSharedLock(Procedure procedure,
                                TableName table)
```
    Try to acquire the shared lock on the specified table. other "read" operations in the table-queue may be executed concurrently,
    
    参数:
    procedure - the procedure trying to acquire the lock
    table - Table to lock
    
    返回:
    true if we were able to acquire the lock on the table, otherwise false.
  - releaseTableSharedLock
```
public void releaseTableSharedLock(Procedure procedure,
                          TableName table)
```
    Release the shared lock taken with tryAcquireTableRead()
    
    参数:
    procedure - the procedure releasing the lock
    table - the name of the table that has the shared lock
  - markTableAsDeleted
```
protected boolean markTableAsDeleted(TableName table)
```
    Tries to remove the queue and the table-lock of the specified table. If there are new operations pending (e.g. a new create), the remove will not be performed.
    
    参数:
    table - the name of the table that should be marked as deleted
    
    返回:
    true if deletion succeeded, false otherwise meaning that there are other new operations pending for that table (e.g. a new create).
  - tryAcquireNamespaceExclusiveLock
```
public boolean tryAcquireNamespaceExclusiveLock(Procedure procedure,
                                       String nsName)
```
    Try to acquire the exclusive lock on the specified namespace.
    
    参数:
    procedure - the procedure trying to acquire the lock
    nsName - Namespace to lock
    
    返回:
    true if we were able to acquire the lock on the namespace, otherwise false.
    另请参阅:
    releaseNamespaceExclusiveLock(Procedure,String)
  - releaseNamespaceExclusiveLock
```
public void releaseNamespaceExclusiveLock(Procedure procedure,
                                 String nsName)
```
    Release the exclusive lock
    
    参数:
    procedure - the procedure releasing the lock
    nsName - the namespace that has the exclusive lock
    另请参阅:
    tryAcquireNamespaceExclusiveLock(Procedure,String)
  - tryAcquireServerExclusiveLock
```
public boolean tryAcquireServerExclusiveLock(Procedure procedure,
                                    ServerName serverName)
```
    Try to acquire the exclusive lock on the specified server.
    
    参数:
    procedure - the procedure trying to acquire the lock
    serverName - Server to lock
    
    返回:
    true if we were able to acquire the lock on the server, otherwise false.
    另请参阅:
    releaseServerExclusiveLock(Procedure,ServerName)
  - releaseServerExclusiveLock
```
public void releaseServerExclusiveLock(Procedure procedure,
                              ServerName serverName)
```
    Release the exclusive lock
    
    参数:
    procedure - the procedure releasing the lock
    serverName - the server that has the exclusive lock
    另请参阅:
    tryAcquireServerExclusiveLock(Procedure,ServerName)
  - tryAcquireServerSharedLock
```
public boolean tryAcquireServerSharedLock(Procedure procedure,
                                 ServerName serverName)
```
    Try to acquire the shared lock on the specified server.
    
    参数:
    procedure - the procedure releasing the lock
    serverName - Server to lock
    
    返回:
    true if we were able to acquire the lock on the server, otherwise false.
    另请参阅:
    releaseServerSharedLock(Procedure,ServerName)
  - releaseServerSharedLock
```
public void releaseServerSharedLock(Procedure procedure,
                           ServerName serverName)
```
    Release the shared lock taken
    
    参数:
    procedure - the procedure releasing the lock
    serverName - the server that has the shared lock
    另请参阅:
    tryAcquireServerSharedLock(Procedure,ServerName)

类 MasterProcedureScheduler

嵌套类概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

MasterProcedureScheduler

方法详细资料

addFront

addBack

yield

poll

clear

signalAll

size

completionCleanup

getPollCalls

getNullPollCalls

waitEvent

waitEvent

suspend

wake

tryAcquireTableExclusiveLock

releaseTableExclusiveLock

tryAcquireTableSharedLock

releaseTableSharedLock

markTableAsDeleted

tryAcquireNamespaceExclusiveLock

releaseNamespaceExclusiveLock

tryAcquireServerExclusiveLock

releaseServerExclusiveLock

tryAcquireServerSharedLock

releaseServerSharedLock