Pauser (OpenHFT/Chronicle-Threads 2.26ea0 API)

All Known Subinterfaces:

TimingPauser

All Known Implementing Classes:

BusyPauser, BusyTimedPauser, LongPauser, MilliPauser, TimeoutPauser, YieldingPauser
```
public interface Pauser
```
Provides a suite of factory methods for creating various Pauser objects, each offering different strategies for managing thread execution. The Pauser is designed to offer flexible pausing strategies depending on CPU availability and desired execution patterns.
This interface also defines the methods for managing pause states and conditions within an application's threading model. It includes methods to pause, unpause, reset, and other utilities that influence thread scheduling and execution behaviors.

Refer to PauserMode for capturing these configurations in a serializable manner.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Pauser.SleepyWarning

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Pauser.SleepyWarning`

Field Summary

Fields
Modifier and Type Field and Description

static boolean BALANCED

static int MIN_BUSY

static int MIN_PROCESSORS

static boolean SLEEPY

Fields
Modifier and Type	Field and Description
`static boolean`	`BALANCED`
`static int`	`MIN_BUSY`
`static int`	`MIN_PROCESSORS`
`static boolean`	`SLEEPY`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default void`	`asyncPause()` Pauses "asynchronously" whereby the issuing EventHandler can pause without blocking other handlers in the EventLoop.
`default boolean`	`asyncPausing()` Checks if the pauser is currently in an asynchronous pause state.
`static TimingPauser`	`balanced()` A balanced pauser which tries to be busy for short bursts but backs off when idle.
`static TimingPauser`	`balancedUpToMillis(int millis)` A balanced pauser which tries to be busy for short bursts but backs off when idle with a limit of max back off.
`static @NotNull Pauser`	`busy()` Creates a `Pauser` that actively keeps the thread busy and does not employ any waiting strategies.
`long`	`countPaused()` Returns the number of times the pauser has checked for completion.
`static boolean`	`getBalanced()`
`static boolean`	`getSleepy()`
`default boolean`	`isBusy()`
`static MilliPauser`	`millis(int millis)` Creates a `MilliPauser` that waits for a fixed duration before resuming execution.
`static Pauser`	`millis(int minMillis, int maxMillis)` Creates a `Pauser` that pauses with a back-off strategy, starting at a minimum millisecond interval and potentially increasing to a maximum.
`void`	`pause()` Pauses the current thread.
`default void`	`pause(long timeout, TimeUnit timeUnit)` use `TimingPauser.pause(long, TimeUnit)` instead
`void`	`reset()` Resets the pauser's internal state back (if any) to the most aggressive setting.
`static TimingPauser`	`sleepy()` A sleepy pauser which yields for a millisecond, then sleeps for 1 to 20 ms
`static @NotNull TimingPauser`	`timedBusy()` Creates a `TimingPauser` that keeps the thread busy but also incorporates timed waits.
`long`	`timePaused()` Returns the paused time so far in milliseconds.
`void`	`unpause()` Try to cancel the pausing if it is pausing.
`static Pauser`	`yielding()` Provides a simple `Pauser` that is more process-friendly by yielding the thread execution.
`static Pauser`	`yielding(int minBusy)` Returns a `Pauser` that either yields, pauses, or does not wait at all, based on system capabilities.

- Field Detail
  - MIN_PROCESSORS
```
static final int MIN_PROCESSORS
```
  - BALANCED
```
static final boolean BALANCED
```
  - SLEEPY
```
static final boolean SLEEPY
```
  - MIN_BUSY
```
static final int MIN_BUSY
```
- Method Detail
  - getBalanced
```
static boolean getBalanced()
```
  - getSleepy
```
static boolean getSleepy()
```
  - yielding
```
static Pauser yielding(int minBusy)
```
    Returns a Pauser that either yields, pauses, or does not wait at all, based on system capabilities. It selects the most appropriate pauser based on CPU availability and specified minimal busyness.
    
    Parameters:
    
    minBusy - the minimal busyness period in microseconds before yielding or pausing
    
    Returns:
    
    the most appropriate Pauser
  - sleepy
```
static TimingPauser sleepy()
```
    A sleepy pauser which yields for a millisecond, then sleeps for 1 to 20 ms
    
    Returns:
    
    a TimingPauser implementing a sleepy strategy
  - balanced
```
static TimingPauser balanced()
```
    A balanced pauser which tries to be busy for short bursts but backs off when idle.
    
    Returns:
    
    a TimingPauser implementing a balanced strategy
  - balancedUpToMillis
```
static TimingPauser balancedUpToMillis(int millis)
```
    A balanced pauser which tries to be busy for short bursts but backs off when idle with a limit of max back off.
    
    Parameters:
    
    millis - the maximum back-off period in milliseconds
    
    Returns:
    
    a TimingPauser implementing a balanced strategy with a maximum back-off limit
  - millis
```
static MilliPauser millis(int millis)
```
    Creates a MilliPauser that waits for a fixed duration before resuming execution.
    
    Parameters:
    
    millis - the fixed wait time in milliseconds
    
    Returns:
    
    a MilliPauser
  - millis
```
static Pauser millis(int minMillis,
                     int maxMillis)
```
    Creates a Pauser that pauses with a back-off strategy, starting at a minimum millisecond interval and potentially increasing to a maximum.
    
    Parameters:
    
    minMillis - the starting minimum pause duration in milliseconds
    
    maxMillis - the maximum pause duration in milliseconds
    
    Returns:
    
    a Pauser with a back-off strategy
  - yielding
```
static Pauser yielding()
```
    Provides a simple Pauser that is more process-friendly by yielding the thread execution.
    
    Returns:
    
    a yielding Pauser
  - busy
```
@NotNull
static @NotNull Pauser busy()
```
    Creates a Pauser that actively keeps the thread busy and does not employ any waiting strategies.
    
    Returns:
    
    a Pauser that never waits
  - timedBusy
```
@NotNull
static @NotNull TimingPauser timedBusy()
```
    Creates a TimingPauser that keeps the thread busy but also incorporates timed waits.
    
    Returns:
    
    a TimingPauser that combines busy and timed wait strategies
  - pause
```
void pause()
```
    Pauses the current thread.
    The actual pause time and thread scheduling impact is not specified and depends on the implementing class. For some implementations, a progressive increase of the pause time is employed, thread executions may or may not be yielded, whereas other implementations may not pause or yield at all.
    Thus, depending on the implementation this could do nothing (busy spin), yield, sleep, ...
    Call this if no work was done.
  - asyncPause
```
default void asyncPause()
```
    Pauses "asynchronously" whereby the issuing EventHandler can pause without blocking other handlers in the EventLoop.
    The issuing EventHandler can check if it is still pausing asynchronously by invoking asyncPausing(). Typically, this is done as depicted below:
```
     // @Override
     public boolean action() throws InvalidEventHandlerException {
       if (pauser.asyncPausing()) {
           // Yield, so that other EventHandlers can run
           return false;
       }
     }
 
```
    See Also:
    
    asyncPausing()
  - asyncPausing
```
default boolean asyncPausing()
```
    Checks if the pauser is currently in an asynchronous pause state.
    
    Returns:
    
    true if the pauser is still pausing asynchronously, false otherwise
  - reset
```
void reset()
```
    Resets the pauser's internal state back (if any) to the most aggressive setting.
    Pausers that progressively increases the pause time are reset back to its lowest pause time.
    Call this if you just did some work.
  - pause
```
default void pause(long timeout,
                   TimeUnit timeUnit)
            throws TimeoutException
```
    use TimingPauser.pause(long, TimeUnit) instead
    
    Throws:
    
    TimeoutException
  - unpause
```
void unpause()
```
    Try to cancel the pausing if it is pausing.
    No guarantee is made that this call will actually have an effect.
  - timePaused
```
long timePaused()
```
    Returns the paused time so far in milliseconds.
    
    Returns:
    
    the paused time so far in milliseconds
  - countPaused
```
long countPaused()
```
    Returns the number of times the pauser has checked for completion.
    
    Returns:
    
    Returns the number of times the pauser has checked for completion
  - isBusy
```
default boolean isBusy()
```
    Returns:
    
    true if it doesn't really pause

Interface Pauser

Nested Class Summary

Field Summary

Method Summary

Field Detail

MIN_PROCESSORS

BALANCED

SLEEPY

MIN_BUSY

Method Detail

getBalanced

getSleepy

yielding

sleepy

balanced

balancedUpToMillis

millis

millis

yielding

busy

timedBusy

pause

asyncPause

asyncPausing

reset

pause

unpause

timePaused

countPaused

isBusy