/// <summary>
/// It is ok to have another thread rerun this method after a halt().
/// </summary>
public void Run()
{
if (!running.AtomicCompareExchange(true, false))
{
throw new InvalidOperationException("Thread is already running");
}
sequenceBarrier.ClearAlert();
NotifyStart();
T @event = null;
var nextSequence = sequence.Value + 1L;
try
{
while (true)
{
try
{
var availableSequence = sequenceBarrier.WaitFor(nextSequence);
///availableSequence=-1 ??????????
while (nextSequence <= availableSequence)
{
@event = dataProvider.Get(nextSequence);
eventHandler.OnEvent(@event, nextSequence, nextSequence == availableSequence);
nextSequence++;
}
sequence.LazySet(availableSequence);
//sequence.Value = availableSequence;
}
catch (TimeoutException e)
{
NotifyTimeout(sequence.Value);
}
catch (AlertException ex)
{
if (!running.ReadFullFence())
{
break;
}
}
catch (Exception ex)
{
exceptionHandler.HandleEventException(ex, nextSequence, @event);
sequence.LazySet(nextSequence);
//sequence.Value = nextSequence;
nextSequence++;
}
}
}
finally
{
NotifyShutdown();
running.WriteFullFence(false);
}
}
/// <summary>
/// It is ok to have another thread rerun this method after a halt().
/// </summary>
public void Run()
{
if (!_running.AtomicCompareExchange(Running, Stopped))
{
throw new InvalidOperationException("Thread is already running");
}
_sequenceBarrier.ClearAlert();
NotifyStart();
T evt = null;
long nextSequence = _sequence.Value + 1L;
while (true)
{
try
{
long availableSequence = _sequenceBarrier.WaitFor(nextSequence);
while (nextSequence <= availableSequence)
{
evt = _ringBuffer[nextSequence];
_eventHandler.OnNext(evt, nextSequence, nextSequence == availableSequence);
nextSequence++;
}
_sequence.LazySet(nextSequence - 1L);
}
catch (AlertException)
{
if (!_running.ReadFullFence())
{
break;
}
}
catch (Exception ex)
{
_exceptionHandler.HandleEventException(ex, nextSequence, evt);
_sequence.LazySet(nextSequence);
nextSequence++;
}
}
NotifyShutdown();
_running.WriteFullFence(Stopped);
}
///<summary>
/// Serialise publishers in sequence and set cursor to latest available sequence.
///</summary>
///<param name="sequence">sequence to be applied</param>
///<param name="cursor">cursor to serialise against.</param>
///<param name="batchSize">batchSize of the sequence.</param>
public override void SerialisePublishing(long sequence, Sequence cursor, long batchSize)
{
long expectedSequence = sequence - batchSize;
while (expectedSequence != cursor.Value)
{
// busy spin
}
cursor.LazySet(sequence);
}
///<summary>
/// Serialise publishers in sequence and set cursor to latest available sequence.
///</summary>
///<param name="sequence">sequence to be applied</param>
///<param name="cursor">cursor to serialise against.</param>
///<param name="batchSize">batchSize of the sequence.</param>
public override void SerialisePublishing(long sequence, Sequence cursor, long batchSize)
{
long expectedSequence = sequence - batchSize;
while (expectedSequence != cursor.Value)
{
// busy spin
}
cursor.LazySet(sequence);
}
///<summary>
/// Serialise publishers in sequence and set cursor to latest available sequence.
///</summary>
///<param name="sequence">sequence to be applied</param>
///<param name="cursor">cursor to serialise against.</param>
///<param name="batchSize">batchSize of the sequence.</param>
public void SerialisePublishing(long sequence, Sequence cursor, long batchSize)
{
cursor.LazySet(sequence);
}
///<summary>
/// Serialise publishers in sequence and set cursor to latest available sequence.
///</summary>
///<param name="sequence">sequence to be applied</param>
///<param name="cursor">cursor to serialise against.</param>
///<param name="batchSize">batchSize of the sequence.</param>
public void SerialisePublishing(long sequence, Sequence cursor, long batchSize)
{
cursor.LazySet(sequence);
}
/// <summary>
/// Force the publication of a cursor sequence.
///
/// Only use this method when forcing a sequence and you are sure only one publisher exists.
/// This will cause the cursor to advance to this sequence.
/// </summary>
/// <param name="sequence">sequence which is to be forced for publication.</param>
public void ForcePublish(long sequence)
{
_cursor.LazySet(sequence);
_waitStrategy.SignalAllWhenBlocking();
}