Disruptor 源码分析(9) 不同等待策略之间的区别

disruptor 不同等待策略之间的区别

几个策略其实没有太多的区别,主要是--counter , Thread.yield(), LockSupport.parkNanos(1L),lock.lock(),超时抛异常其中的一种货多种的组合.

WaitStrategy有好几个实现类:

SleepingWaitStrategy 是这样的

while ((availableSequence = dependentSequence.get()) < sequence)
        {
            counter = applyWaitMethod(barrier, counter);
        }

 private int applyWaitMethod(final SequenceBarrier barrier, int counter)
        throws AlertException
    {
        barrier.checkAlert();

        if (counter > 100)
        {
            --counter;
        }
        else if (counter > 0)
        {
            --counter;
            Thread.yield();
        }
        else
        {
            LockSupport.parkNanos(1L);
        }

可以看到是--counter和Thread.yield()和LockSupport.parkNanos(1L)的混合.

PhasedBackoffWaitStrategy 是这样的:

 do
        {
            if ((availableSequence = dependentSequence.get()) >= sequence)
            {
                return availableSequence;
            }

            if (0 == --counter)
            {
                if (0 == startTime)
                {
                    startTime = System.nanoTime();
                }
                else
                {
                    long timeDelta = System.nanoTime() - startTime;
                    if (timeDelta > yieldTimeoutNanos)
                    {
                        return lockingStrategy.waitOnLock(sequence, cursor, dependentSequence, barrier);
                    }
                    else if (timeDelta > spinTimeoutNanos)
                    {
                        Thread.yield();
                    }
                }
                counter = SPIN_TRIES;
            }
        }
        while (true);

先是计算器不断-1.然后是Thread.yield();,然后是BlockingStrategy. BlockingStrategy会通过lock.lock();来实现.

BlockingWaitStrategy 是这样的:
就是ReentrantLock的lock和unlock 和等待publish的唤醒.

BusySpinWaitStrategy 是这样的:

 while ((availableSequence = dependentSequence.get()) < sequence)
        {
            barrier.checkAlert();
        }

可以看到是while一直不停的循环,对cpu的压力是很大的.


TimeoutBlockingWaitStrategy  是这样的:
 

lock.lock();
            try
            {
                while ((availableSequence = cursorSequence.get()) < sequence)
                {
                    barrier.checkAlert();
                    nanos = processorNotifyCondition.awaitNanos(nanos);
                    if (nanos <= 0)
                    {
                        throw TimeoutException.INSTANCE;
                    }

也是会加锁先.但是超过一定时间就是抛异常.


YieldingWaitStrategy是这样的:

while ((availableSequence = dependentSequence.get()) < sequence)
        {
            counter = applyWaitMethod(barrier, counter);
        }

 private int applyWaitMethod(final SequenceBarrier barrier, int counter)
        throws AlertException
    {
        if (0 == counter)
        {
            Thread.yield();
        }
        else
        {
            --counter;
        }

可以看到是--counter和Thread.yield()的混合.