AffinityLock (OpenHFT/Java-Thread-Affinity/affinity 3.26ea4 API)

java.lang.Object
- net.openhft.affinity.AffinityLock

All Implemented Interfaces:

Closeable, AutoCloseable
```
public class AffinityLock
extends Object
implements Closeable
```
This utility class support locking a thread to a single core, or reserving a whole core for a thread.

Author:

peter.lawrey

Field Summary

Fields
Modifier and Type Field and Description

static String AFFINITY_RESERVED

static BitSet BASE_AFFINITY

static int PROCESSORS

static BitSet RESERVED_AFFINITY

Fields
Modifier and Type	Field and Description
`static String`	`AFFINITY_RESERVED`
`static BitSet`	`BASE_AFFINITY`
`static int`	`PROCESSORS`
`static BitSet`	`RESERVED_AFFINITY`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static AffinityLock`	`acquireCore()` Assign any free core to this thread.
`static AffinityLock`	`acquireCore(boolean bind)` Assign a core(and all its cpus) which can be bound to the current thread or another thread.
`static AffinityLock`	`acquireLock()` Assign any free cpu to this thread.
`AffinityLock`	`acquireLock(AffinityStrategy... strategies)` Give another affinity lock relative to this one based on a list of strategies.
`static AffinityLock`	`acquireLock(boolean bind)` Assign a cpu which can be bound to the current thread or another thread.
`static AffinityLock`	`acquireLock(int cpuId)` Assign a cpu which can be bound to the current thread or another thread.
`static AffinityLock`	`acquireLock(int[] cpus)` Assign a cpu which can be bound to the current thread or another thread Caller passes in an explicit set of preferred CPUs The first available CPU is used, and the lock returned If all CPUs in the set are unavailable then no lock is obtained
`static AffinityLock`	`acquireLock(String desc)` Use a description to allocate a cpu.
`static AffinityLock`	`acquireLockLastMinus(int n)` Allocate from the end.
`void`	`bind()` Bind the current thread to this reservable lock.
`void`	`bind(boolean wholeCore)` Bind the current thread to this reservable lock.
`void`	`close()`
`int`	`cpuId()`
`static @NotNull CpuLayout`	`cpuLayout()`
`static void`	`cpuLayout(@NotNull CpuLayout cpuLayout)` Set the CPU layout for this machine.
`static @NotNull String`	`dumpLocks()`
`protected void`	`finalize()`
`boolean`	`isAllocated()`
`boolean`	`isBound()`
`void`	`release()` Release the current AffinityLock which can be discarded.
`boolean`	`resetAffinity()`
`AffinityLock`	`resetAffinity(boolean resetAffinity)`
`String`	`toString()`

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

- Field Detail
  - AFFINITY_RESERVED
```
public static final String AFFINITY_RESERVED
```
    See Also:
    
    Constant Field Values
  - PROCESSORS
```
public static final int PROCESSORS
```
  - BASE_AFFINITY
```
public static final BitSet BASE_AFFINITY
```
  - RESERVED_AFFINITY
```
public static final BitSet RESERVED_AFFINITY
```
- Method Detail
  - cpuLayout
```
public static void cpuLayout(@NotNull
                             @NotNull CpuLayout cpuLayout)
```
    Set the CPU layout for this machine. CPUs which are not mentioned will be ignored.
    Changing the layout will have no impact on thread which have already been assigned. It only affects subsequent assignments.
    
    Parameters:
    
    cpuLayout - for this application to use for this machine.
  - cpuLayout
```
@NotNull
public static @NotNull CpuLayout cpuLayout()
```
    Returns:
    
    The current CpuLayout for the application.
  - acquireLock
```
public static AffinityLock acquireLock()
```
    Assign any free cpu to this thread.
    
    Returns:
    
    A handle for the current AffinityLock.
  - acquireCore
```
public static AffinityLock acquireCore()
```
    Assign any free core to this thread.
    In reality, only one cpu is assigned, the rest of the threads for that core are reservable so they are not used.
    
    Returns:
    
    A handle for the current AffinityLock.
  - acquireLock
```
public static AffinityLock acquireLock(boolean bind)
```
    Assign a cpu which can be bound to the current thread or another thread.
    This can be used for defining your thread layout centrally and passing the handle via dependency injection.
    
    Parameters:
    
    bind - if true, bind the current thread, if false, reserve a cpu which can be bound later.
    
    Returns:
    
    A handle for an affinity lock.
  - acquireLock
```
public static AffinityLock acquireLock(int cpuId)
```
    Assign a cpu which can be bound to the current thread or another thread.
    This can be used for defining your thread layout centrally and passing the handle via dependency injection.
    
    Parameters:
    
    cpuId - the CPU id to bind to
    
    Returns:
    
    A handle for an affinity lock.
  - acquireLock
```
public static AffinityLock acquireLock(int[] cpus)
```
    Assign a cpu which can be bound to the current thread or another thread Caller passes in an explicit set of preferred CPUs The first available CPU is used, and the lock returned If all CPUs in the set are unavailable then no lock is obtained
    
    Parameters:
    
    cpus - the array of available CPUs to bind to
    
    Returns:
    
    A handle for an affinity lock, or nolock if no available CPU in the array
  - acquireLockLastMinus
```
public static AffinityLock acquireLockLastMinus(int n)
```
    Allocate from the end.
    
    Parameters:
    
    n - positive number to allocate from.
    
    Returns:
    
    the lock acquired
  - acquireLock
```
public static AffinityLock acquireLock(String desc)
```
    Use a description to allocate a cpu.
    - "N" being a positive integer means allocate this CPU,
    - "last" or "last-N" means allocate from the end,
    - "csv:1,2,5,6 eg means allocate first free core from the provided
    - "any" means allow any
    - "none" or null means
    - "0" is not allowed
    Parameters:
    
    desc - of which cpu to pick
    
    Returns:
    
    the AffinityLock obtained
  - acquireCore
```
public static AffinityLock acquireCore(boolean bind)
```
    Assign a core(and all its cpus) which can be bound to the current thread or another thread.
    This can be used for defining your thread layout centrally and passing the handle via dependency injection.
    
    Parameters:
    
    bind - if true, bind the current thread, if false, reserve a cpu which can be bound later.
    
    Returns:
    
    A handle for an affinity lock.
  - dumpLocks
```
@NotNull
public static @NotNull String dumpLocks()
```
    Returns:
    
    All the current locks as a String.
  - resetAffinity
```
public boolean resetAffinity()
```
    Returns:
    
    Whether to reset the affinity, false indicates the thread is about to die anyway.
  - resetAffinity
```
public AffinityLock resetAffinity(boolean resetAffinity)
```
    Parameters:
    
    resetAffinity - Whether to reset the affinity, false indicates the thread is about to die anyway.
    
    Returns:
    
    this
  - bind
```
public void bind()
```
    Bind the current thread to this reservable lock.
  - bind
```
public void bind(boolean wholeCore)
```
    Bind the current thread to this reservable lock.
    
    Parameters:
    
    wholeCore - if true, also reserve the whole core.
  - acquireLock
```
public AffinityLock acquireLock(AffinityStrategy... strategies)
```
    Give another affinity lock relative to this one based on a list of strategies.
    The strategies are evaluated in order to (like a search path) to find the next appropriate thread. If ANY is not the last strategy, a warning is logged and no cpu is assigned (leaving the OS to choose)
    
    Parameters:
    
    strategies - To determine if you want the same/different core/socket.
    
    Returns:
    
    A matching AffinityLock.
  - release
```
public void release()
```
    Release the current AffinityLock which can be discarded.
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - cpuId
```
public int cpuId()
```
    Returns:
    
    unique id for this CPI or -1 if not allocated.
  - isAllocated
```
public boolean isAllocated()
```
    Returns:
    
    Was a cpu found to bind this lock to.
  - isBound
```
public boolean isBound()
```
    Returns:
    
    Has this AffinityLock been bound?
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AffinityLock

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

AFFINITY_RESERVED

PROCESSORS

BASE_AFFINITY

RESERVED_AFFINITY

Method Detail

cpuLayout

cpuLayout

acquireLock

acquireCore

acquireLock

acquireLock

acquireLock

acquireLockLastMinus

acquireLock

acquireCore

dumpLocks

resetAffinity

resetAffinity

bind

bind

acquireLock

release

close

finalize

cpuId

isAllocated

isBound

toString