MultiVersionConcurrencyControl (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.MultiVersionConcurrencyControl

```
@InterfaceAudience.Private
public class MultiVersionConcurrencyControl
extends Object
```
Manages the read/write consistency. This provides an interface for readers to determine what entries to ignore, and a mechanism for writers to obtain new write numbers, then "commit" the new writes for readers to read (thus forming atomic transactions).

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`MultiVersionConcurrencyControl.WriteEntry` Write number and whether write has completed given out at start of a write transaction.

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`FIXED_SIZE`
`private static org.slf4j.Logger`	`LOG`
`static long`	`NONE` Represents no value, or not set.
`(package private) AtomicLong`	`readPoint`
`private static long`	`READPOINT_ADVANCE_WAIT_TIME`
`private Object`	`readWaiters`
`(package private) String`	`regionName`
`(package private) AtomicLong`	`writePoint`
`private LinkedList<MultiVersionConcurrencyControl.WriteEntry>`	`writeQueue`

Constructor Summary

Constructors
Constructor and Description
`MultiVersionConcurrencyControl()`
`MultiVersionConcurrencyControl(long startPoint)` Construct and set read point.
`MultiVersionConcurrencyControl(String regionName)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`advanceTo(long newStartPoint)` Step the MVCC forward on to a new read/write basis.
`void`	`await()` Wait until the read point catches up to the write point; i.e.
`MultiVersionConcurrencyControl.WriteEntry`	`begin()` Call `begin(Runnable)` with an empty `Runnable`.
`MultiVersionConcurrencyControl.WriteEntry`	`begin(Runnable action)` Start a write transaction.
`boolean`	`complete(MultiVersionConcurrencyControl.WriteEntry writeEntry)` Mark the `MultiVersionConcurrencyControl.WriteEntry` as complete and advance the read point as much as possible.
`void`	`completeAndWait(MultiVersionConcurrencyControl.WriteEntry e)` Complete a `MultiVersionConcurrencyControl.WriteEntry` that was created by `begin()` then wait until the read point catches up to our write.
`long`	`getReadPoint()`
`long`	`getWritePoint()`
`String`	`toString()`
`(package private) boolean`	`tryAdvanceTo(long newStartPoint, long expected)` Step the MVCC forward on to a new read/write basis.
`(package private) void`	`waitForRead(MultiVersionConcurrencyControl.WriteEntry e)` Wait for the global readPoint to advance up to the passed in write entry number.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - READPOINT_ADVANCE_WAIT_TIME
```
private static final long READPOINT_ADVANCE_WAIT_TIME
```
    See Also:
    
    Constant Field Values
  - regionName
```
final String regionName
```
  - readPoint
```
final AtomicLong readPoint
```
  - writePoint
```
final AtomicLong writePoint
```
  - readWaiters
```
private final Object readWaiters
```
  - NONE
```
public static final long NONE
```
    Represents no value, or not set.
    
    See Also:
    
    Constant Field Values
  - writeQueue
```
private final LinkedList<MultiVersionConcurrencyControl.WriteEntry> writeQueue
```
  - FIXED_SIZE
```
public static final long FIXED_SIZE
```
- Constructor Detail
  - MultiVersionConcurrencyControl
```
public MultiVersionConcurrencyControl()
```
  - MultiVersionConcurrencyControl
```
public MultiVersionConcurrencyControl(String regionName)
```
  - MultiVersionConcurrencyControl
```
public MultiVersionConcurrencyControl(long startPoint)
```
    Construct and set read point. Write point is uninitialized.
- Method Detail
  - advanceTo
```
public void advanceTo(long newStartPoint)
```
    Step the MVCC forward on to a new read/write basis. n
  - tryAdvanceTo
```
boolean tryAdvanceTo(long newStartPoint,
                     long expected)
```
    Step the MVCC forward on to a new read/write basis.
    
    Parameters:
    
    newStartPoint - Point to move read and write points to.
    
    expected - If not -1 (#NONE)
    
    Returns:
    
    Returns false if expected is not equal to the current readPoint or if startPoint is less than current readPoint
  - begin
```
public MultiVersionConcurrencyControl.WriteEntry begin()
```
    Call begin(Runnable) with an empty Runnable.
  - begin
```
public MultiVersionConcurrencyControl.WriteEntry begin(Runnable action)
```
    Start a write transaction. Create a new MultiVersionConcurrencyControl.WriteEntry with a new write number and add it to our queue of ongoing writes. Return this WriteEntry instance. To complete the write transaction and wait for it to be visible, call completeAndWait(WriteEntry). If the write failed, call complete(WriteEntry) so we can clean up AFTER removing ALL trace of the failed write transaction.
    The action will be executed under the lock which means it can keep the same order with mvcc.
    
    See Also:
    
    complete(WriteEntry), completeAndWait(WriteEntry)
  - await
```
public void await()
```
    Wait until the read point catches up to the write point; i.e. wait on all outstanding mvccs to complete.
  - completeAndWait
```
public void completeAndWait(MultiVersionConcurrencyControl.WriteEntry e)
```
    Complete a MultiVersionConcurrencyControl.WriteEntry that was created by begin() then wait until the read point catches up to our write. At the end of this call, the global read point is at least as large as the write point of the passed in WriteEntry. Thus, the write is visible to MVCC readers.
  - complete
```
public boolean complete(MultiVersionConcurrencyControl.WriteEntry writeEntry)
```
    Mark the MultiVersionConcurrencyControl.WriteEntry as complete and advance the read point as much as possible. Call this even if the write has FAILED (AFTER backing out the write transaction changes completely) so we can clean up the outstanding transaction. How much is the read point advanced? Let S be the set of all write numbers that are completed. Set the read point to the highest numbered write of S. n *
    
    Returns:
    
    true if e is visible to MVCC readers (that is, readpoint >= e.writeNumber)
  - waitForRead
```
void waitForRead(MultiVersionConcurrencyControl.WriteEntry e)
```
    Wait for the global readPoint to advance up to the passed in write entry number.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getReadPoint
```
public long getReadPoint()
```
  - getWritePoint
```
public long getWritePoint()
```

Class MultiVersionConcurrencyControl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

READPOINT_ADVANCE_WAIT_TIME

regionName

readPoint

writePoint

readWaiters

NONE

writeQueue

FIXED_SIZE

Constructor Detail

MultiVersionConcurrencyControl

MultiVersionConcurrencyControl

MultiVersionConcurrencyControl

Method Detail

advanceTo

tryAdvanceTo

begin

begin

await

completeAndWait

complete

waitForRead

toString

getReadPoint

getWritePoint