com.github.rollingmetrics.blocks

Class BufferedActor<T extends BufferedActor.ReusableActionContainer>

java.lang.Object

com.github.rollingmetrics.blocks.BufferedActor<T>

Type Parameters:

T -

public class BufferedActor<T extends BufferedActor.ReusableActionContainer>
extends Object

Primary intention of this class is replacing the blocking by buffering for complex monitoring metrics which can not be implemented(or it is too complex to implement) as none-blocking structure. With BufferedActor you can threat your code as lock-free as long as it is enough place in the buffer, when place in the buffer is left then BufferedActor downgrades processing to the blocking paradigm, but this case should happen rarely because typical application does something useful between metric publishing, in other words it is not likely that your application spent more time in metrics logging instead of doing real work.

Second intention is provide garbage-free style of metrics collection. If underling data-structure does not perform memory allocation on each update, then BufferedActor will help to organize message passing in the way that does not require node allocation when placing task to the buffer.

Implementation details:

• At initialization time BufferedActor pre-allocates buffer with actions, then actions are reused.
• On each time only one thread allowed to do an action.
• Instead of blocking this class does the buffering of actions if there is a thread in the progress. That means that computation can be completed somewhere in the future, but it is not a problem because when you update an metric you never expect the result.
• Thread in progress does its work in batches instead of applying action one by one, that means that when thread finished its own action it helps to complete actions scheduled by other threads
• In order to avoid live lock(when too many parallel treads are scheduling) each active thread is allowed to process no more that maxBatchSize actions at once.
• An thread can be blocked if and only if there are no available actions in the pool, in such case blocked tread helps to process accumulated buffer.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	BufferedActor.ReusableActionContainer

Constructor Summary

Constructors

Constructor and Description
BufferedActor(Supplier<T> actionFactory, int bufferSize, int minBatchSize, int maxBatchSize)

Method Summary

Modifier and Type	Method and Description
void	clear()
void	doExclusivelyOrSchedule(BufferedActor.ReusableActionContainer action)
T	getActionFromPool()
long	getOverflowedCount()
void	processAllScheduledActions()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BufferedActor

public BufferedActor(Supplier<T> actionFactory,
                     int bufferSize,
                     int minBatchSize,
                     int maxBatchSize)

Parameters:

actionFactory - factory which used to populate action pool, pool is always populated to maximum during initialization

bufferSize - the size of queue for incoming requests

minBatchSize -

maxBatchSize - specifies how many actions one thread is allowed to perform in single batch, intent of this parameter is to avoid live lock of exclusive lock owner

Method Detail

getActionFromPool

public final T getActionFromPool()

doExclusivelyOrSchedule

public void doExclusivelyOrSchedule(BufferedActor.ReusableActionContainer action)

getOverflowedCount

public long getOverflowedCount()

processAllScheduledActions

public void processAllScheduledActions()

clear

public void clear()