RandomDataUpdate (OpenHFT/Java-Lang/lang 6.6.7 API)

All Known Subinterfaces:

Bytes, IByteBufferBytes

All Known Implementing Classes:

AbstractBytes, BoundsCheckingDirectBytes, BoundsCheckingNativeBytes, ByteBufferBytes, CheckedBytes, DirectByteBufferBytes, DirectBytes, MappedNativeBytes, MultiStoreBytes, NativeBytes, VanillaMappedBytes, WrappedBytes
```
public interface RandomDataUpdate
```
This class supports updates which are a companion to RandomDataInput and RandomDataOutput

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`addAtomicDouble(long offset, double d)`
`float`	`addAtomicFloat(long offset, float f)`
`int`	`addAtomicInt(long offset, int i)`
`long`	`addAtomicLong(long offset, long l)`
`byte`	`addByte(long offset, byte b)`
`double`	`addDouble(long offset, double d)`
`float`	`addFloat(long offset, float f)`
`int`	`addInt(long offset, int i)`
`long`	`addLong(long offset, long i)`
`short`	`addShort(long offset, short s)`
`int`	`addUnsignedByte(long offset, int i)`
`long`	`addUnsignedInt(long offset, long i)`
`int`	`addUnsignedShort(long offset, int i)`
`void`	`busyLockInt(long offset)` Lock which uses 4 bytes.
`void`	`busyLockLong(long offset)` Lock across processes
`void`	`resetLockInt(long offset)` Lock which uses 4 bytes.
`void`	`resetLockLong(long offset)` Lock which uses 8 bytes.
`int`	`threadIdForLockInt(long offset)` Lock which uses 4 bytes.
`long`	`threadIdForLockLong(long offset)` Lock which uses 8 bytes.
`boolean`	`tryLockInt(long offset)` Lock which uses 4 bytes.
`boolean`	`tryLockLong(long offset)` Lock across processes
`boolean`	`tryLockNanosInt(long offset, long nanos)` Lock which uses 4 bytes.
`boolean`	`tryLockNanosLong(long offset, long nanos)` Lock across processes
`boolean`	`tryRWReadLock(long offset, long timeOutNS)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`boolean`	`tryRWWriteLock(long offset, long timeOutNS)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`void`	`unlockInt(long offset)` Lock which uses 4 bytes.
`void`	`unlockLong(long offset)` Lock across processes
`void`	`unlockRWReadLock(long offset)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`void`	`unlockRWWriteLock(long offset)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.

- Method Detail
  - addByte
```
byte addByte(long offset,
           byte b)
```
  - addUnsignedByte
```
int addUnsignedByte(long offset,
                  int i)
```
  - addShort
```
short addShort(long offset,
             short s)
```
  - addUnsignedShort
```
int addUnsignedShort(long offset,
                   int i)
```
  - addInt
```
int addInt(long offset,
         int i)
```
  - addUnsignedInt
```
long addUnsignedInt(long offset,
                  long i)
```
  - addLong
```
long addLong(long offset,
           long i)
```
  - addFloat
```
float addFloat(long offset,
             float f)
```
  - addDouble
```
double addDouble(long offset,
               double d)
```
  - addAtomicInt
```
int addAtomicInt(long offset,
               int i)
```
  - addAtomicLong
```
long addAtomicLong(long offset,
                 long l)
```
  - addAtomicFloat
```
float addAtomicFloat(long offset,
                   float f)
```
  - addAtomicDouble
```
double addAtomicDouble(long offset,
                     double d)
```
  - tryLockInt
```
boolean tryLockInt(long offset)
```
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Parameters:
    offset - of the start of the 4-byte lock
    
    Returns:
    did it lock or not.
  - tryLockNanosInt
```
boolean tryLockNanosInt(long offset,
                      long nanos)
```
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Parameters:
    offset - of the start of the 4-byte lock
    nanos - to try to lock for
    
    Returns:
    did it lock or not.
  - busyLockInt
```
void busyLockInt(long offset)
                 throws InterruptedException,
                        IllegalStateException
```
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Parameters:
    offset - of the start of the 4-byte lock
    
    Throws:
    
    InterruptedException - if interrupted
    
    IllegalStateException - if the thread tries to lock it 255 nested time (without an unlock)
  - unlockInt
```
void unlockInt(long offset)
               throws IllegalMonitorStateException
```
    Lock which uses 4 bytes. Unlock this It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Parameters:
    offset - of the start of the 4-byte lock
    
    Throws:
    
    IllegalMonitorStateException - if this thread doesn't hold the lock
  - resetLockInt
```
void resetLockInt(long offset)
```
    Lock which uses 4 bytes. Reset forces the lock to be cleared. Use this only when the program believes the locked thread is dead.
    
    Parameters:
    offset - of the start of the 4-byte lock
  - threadIdForLockInt
```
int threadIdForLockInt(long offset)
```
    Lock which uses 4 bytes. This returns the lower bytes which contain the threadId.
    
    Parameters:
    offset - of the start of the 4-byte lock
    
    Returns:
    the threadId or 0 if no thread holds the lock.
  - tryLockLong
```
boolean tryLockLong(long offset)
```
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Parameters:
    offset - of the start of the 8-byte lock
    
    Returns:
    did it lock or not.
  - tryLockNanosLong
```
boolean tryLockNanosLong(long offset,
                       long nanos)
```
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Parameters:
    offset - of the start of the 8-byte lock
    nanos - to try to lock for
    
    Returns:
    did it lock or not.
  - busyLockLong
```
void busyLockLong(long offset)
                  throws InterruptedException,
                         IllegalStateException
```
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Parameters:
    offset - of the start of the 8-byte lock
    
    Throws:
    
    InterruptedException - if interrupted
    
    IllegalStateException - if the thread tries to lock it 65535 nested time (without an unlock)
  - unlockLong
```
void unlockLong(long offset)
                throws IllegalMonitorStateException
```
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Parameters:
    offset - of the start of the 8-byte lock
    
    Throws:
    
    IllegalMonitorStateException - if this thread doesn't hold the lock
  - resetLockLong
```
void resetLockLong(long offset)
```
    Lock which uses 8 bytes. Reset forces the lock to be cleared. Use this only when the program believes the locked thread is dead.
    
    Parameters:
    offset - of the start of the 8-byte lock
  - threadIdForLockLong
```
long threadIdForLockLong(long offset)
```
    Lock which uses 8 bytes. This returns the lower bytes which contain the threadId.
    
    Parameters:
    offset - of the start of the 8-byte lock
    
    Returns:
    the threadId or 0 if no thread holds the lock.
  - tryRWReadLock
```
boolean tryRWReadLock(long offset,
                    long timeOutNS)
                      throws IllegalStateException,
                             InterruptedException
```
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Parameters:
    offset - of the long monitor
    timeOutNS - length of time to busy wait for the lock.
    
    Returns:
    if the lock could be obtained in time.
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
    
    InterruptedException
  - tryRWWriteLock
```
boolean tryRWWriteLock(long offset,
                     long timeOutNS)
                       throws IllegalStateException,
                              InterruptedException
```
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Parameters:
    offset - of the long monitor
    timeOutNS - length of time to busy wait for the lock.
    
    Returns:
    if the lock could be obtained in time.
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
    
    InterruptedException
  - unlockRWReadLock
```
void unlockRWReadLock(long offset)
                      throws IllegalStateException
```
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Parameters:
    offset - of the long monitor
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
  - unlockRWWriteLock
```
void unlockRWWriteLock(long offset)
                       throws IllegalStateException
```
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Parameters:
    offset - of the long monitor
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state

Interface RandomDataUpdate

Method Summary

Method Detail

addByte

addUnsignedByte

addShort

addUnsignedShort

addInt

addUnsignedInt

addLong

addFloat

addDouble

addAtomicInt

addAtomicLong

addAtomicFloat

addAtomicDouble

tryLockInt

tryLockNanosInt

busyLockInt

unlockInt

resetLockInt

threadIdForLockInt

tryLockLong

tryLockNanosLong

busyLockLong

unlockLong

resetLockLong

threadIdForLockLong

tryRWReadLock

tryRWWriteLock

unlockRWReadLock

unlockRWWriteLock