非阻塞同步算法实战（三）－LatestResultsProvider

/**
 * @author trytocatch@163.com
 * @date 2013-2-2
 */
public abstract class LatestResultsProvider {
    /** update return value */
    public static final int UPDATE_FAILED = -1;
    public static final int UPDATE_NO_NEED_TO_UPDATE = 0;
    public static final int UPDATE_SUCCESS = 1;
    public static final int UPDATE_COMMITTED = 2;
    /** update return value */
    /** work states*/
    private static final int WS_OFF = 0;
    private static final int WS_NEW_TASK = 1;
    private static final int WS_WORKING = 2;
    private static final int WS_DELAYING = 3;
    private static final int WS_DELAY_RESET = 4;
    private static final int WS_CANCELED = 5;
    /** work states*/
    private final AtomicInteger workState;
    private int sleepPeriod = 30;
    private final AtomicInteger parametersVersion;
    private volatile int updateDelay;// updateDelay>=0
    private volatile int delayUpperLimit;
    private final BoundlessCyclicBarrier barrier;
    private Thread workThread;
    /**
     *
     * @param updateDelay unit: millisecond
     * @param delayUpperLimit limit the sum of the delay, disabled
     * while delayUpperLimit 0 ? WS_DELAY_RESET : WS_WORKING)) {
                            if (workState.compareAndSet(WS_CANCELED, WS_OFF)) {
                                barrier.cancel();
                            }
                            LockSupport.park();
                            interrupted();
                        }
                        if (workState.get() == WS_DELAY_RESET) {
                            int delaySum = 0;
                            for (;;) {
                                if (workState.compareAndSet(WS_DELAY_RESET,
                                        WS_DELAYING)) {
                                    sleepCount = (updateDelay + sleepPeriod - 1)
                                            / sleepPeriod;
                                }
                                sleep(sleepPeriod);
                                if (--sleepCount = 0) {
                                    delaySum += sleepPeriod;
                                    if (delaySum >= delayUpperLimit) {
                                        if (!workState.compareAndSet(
                                                WS_DELAYING, WS_WORKING))
                                            workState.compareAndSet(
                                                    WS_DELAY_RESET, WS_WORKING);
                                        break;
                                    }
                                }
                                if (workState.get() != WS_DELAYING
                                        && workState.get() != WS_DELAY_RESET)
                                    break;
                            }
                        }
                        if (isWorking()) {
                            int workingVersion = parametersVersion.get();
                            try {
                                calculateResult();
                                if (workState.compareAndSet(WS_WORKING, WS_OFF))
                                    barrier.nextCycle(workingVersion);
                            } catch (Throwable t) {
                                t.printStackTrace();
                                workState.set(WS_CANCELED);
                            }
                        }
                    } catch (InterruptedException e) {
                        workState.compareAndSet(WS_DELAYING, WS_CANCELED);
                        workState.compareAndSet(WS_DELAY_RESET, WS_CANCELED);
                    }
                }// for(;;)
            }// run()
        };
        workThread.setDaemon(true);
        workThread.start();
    }
    public int getUpdateDelay() {
        return updateDelay;
    }
    /**
     * @param updateDelay
     *            delay time. unit: millisecond
     */
    public void setUpdateDelay(int updateDelay) {
        this.updateDelay = updateDelay 
<p>代码中，我直接在构造方法里开启了新的线程，一般来说，是不推荐这样做的，但在此处，除非在构造还未完成时就执行update方法，否则不会引发什么问题。</p>
<p>最后，附上该正则替换工具的介绍和下载地址：http://www.cnblogs.com/trytocatch/p/RegexReplacer.html</p>
<h2>小结</h2>
<p>状态变更非常适合使用非阻塞算法，并且还能够达到wait-free级别。限于篇幅，有些没讲到的细节，请读者借助代码来理解吧，如有疑问，欢迎回复讨论。</p>
<h2>系列总结</h2>
<p>本实战系列就到此结束了，简单总结下。</p>
<p>非阻塞同步相对于锁同步而言，由代码块，转为了点，是另一种思考方式。</p>
<p>有时，无法做到一步完成，也许可以分成两步完成，同样可以解决问题，ConcurrentLinkedQueue就是这么做的。</p>
<p>如果需要维护多个数据之间的某种一致关系，则可以将它们封装到一个类中，更新时采用更新该类对象的引用的方式。</p>
<p>众所周知，锁同步算法是难以测试的，非阻塞同步算法更加难以测试，我个人认为，其正确性主要靠慎密的推敲和论证。</p>
<p>非阻塞同步算法比锁同步算法要显得更复杂些，如果对性能要求不高，对非阻塞算法掌握得还不太熟练，建议不要使用非阻塞算法，锁同步算法要简洁得多，也更容易维护，如上面所说的，两条看似没有顺序的语句，调换下顺序，可能就会引发BUG。</p>

    <p class="copyright">
        原文地址：非阻塞同步算法实战（三）－LatestResultsProvider, 感谢原作者分享。
    </p>