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

All Known Subinterfaces:

Bytes

All Known Implementing Classes:

AbstractBytes, ByteBufferBytes, DirectBytes, MultiStoreBytes, NativeBytes
```
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 Lock which uses 8 bytes.
`boolean`	`tryLockInt(long offset)` Lock which uses 4 bytes.
`boolean`	`tryLockLong(long offset)` Lock across processes Lock which uses 8 bytes.
`boolean`	`tryLockNanosInt(long offset, long nanos)` Lock which uses 4 bytes.
`boolean`	`tryLockNanosLong(long offset, long nanos)` Lock across processes Lock which uses 8 bytes.
`void`	`unlockInt(long offset)` Lock which uses 4 bytes.
`void`	`unlockLong(long offset)` Lock across processes Lock which uses 8 bytes.

- 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
  - 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

Interface RandomDataUpdate

Method Summary

Method Detail

addByte

addUnsignedByte

addShort

addUnsignedShort

addInt

addUnsignedInt

addLong

addFloat

addDouble

addAtomicInt

addAtomicLong

addAtomicFloat

addAtomicDouble

tryLockInt

tryLockNanosInt

busyLockInt

unlockInt

tryLockLong

tryLockNanosLong

busyLockLong

unlockLong