JeffreyZhao/FineLockCalculator.cs

## FineLockCalculator.cs
// 其实这题可以写的很简单，它的关键根本不是CAS操作。

// 使用一个标志（flag也好，status判断也罢）来避免Start和Dispose重入是很容易
// 想到的手段，很多同学也这么做了。大部分同学遇到的问题是：假如StartCore已经
// 启动，那么如何让Dispose方法等待其完成。有些同学用while (true)，有些同学用
// 锁，但都避免不了让Dispose线程等待Start线程。

// 这里“避免等待”的关键在于要跳出思维界限：谁说DisposeCore方法一定要在Dispose
// 方法里执行的？我们就不能在Start里销毁对象吗？

public class FineLockCalculator : CalculatorBase {

    private enum Status {
        NotStarted,
        Starting,
        Started,
        Disposed
    }

    private readonly object _gate = new object();

    private Status _status = Status.NotStarted;

    public virtual void Start() {
        lock (_gate) {
            if (_status != Status.NotStarted)
                return;

            _status = Status.Starting;
        }

        StartCore();

        lock (_gate) {
            if (_status == Status.Starting) {
                _status = Status.Started;
                return;
            }
        }

        DisposeCore();
    }

    public void Dispose() {
        lock (_gate) {
            var origStatus = _status;
            _status = Status.Disposed;

            if (origStatus != Status.Started)
                return;
        }

        DisposeCore();
    }
}

// 在Dispose方法中，我们对_status进行标记，但只在确定Started的情况下才
// 调用DisposeCore。同理，在Start方法中假如发现_status已经变成了Disposed，
// 则原地调用DisposeCore销毁对象。使用这种方法，Dispose方法完全不需要做
// 任何等待，整体等待时间极短。

// 清晰起见，上述代码没有使用任何CAS操作，只是对于_status读写加以简单保护。
// 假如需要的话，我们也可以把三个lock轻松修改为CAS操作，但这只是起到锦上
// 添花的作用。

// 有些同学一上来就搞CAS，然后发现问题之后只是简单的修补，于是代码越变越
// 复杂。理清思路，划分好边界，处理好边界上的竞争关系，其实逻辑说到底就是
// 这么简单.
	// 其实这题可以写的很简单，它的关键根本不是CAS操作。

	// 使用一个标志（flag也好，status判断也罢）来避免Start和Dispose重入是很容易
	// 想到的手段，很多同学也这么做了。大部分同学遇到的问题是：假如StartCore已经
	// 启动，那么如何让Dispose方法等待其完成。有些同学用while (true)，有些同学用
	// 锁，但都避免不了让Dispose线程等待Start线程。

	// 这里“避免等待”的关键在于要跳出思维界限：谁说DisposeCore方法一定要在Dispose
	// 方法里执行的？我们就不能在Start里销毁对象吗？

	public class FineLockCalculator : CalculatorBase {

	private enum Status {
	NotStarted,
	Starting,
	Started,
	Disposed
	}

	private readonly object _gate = new object();

	private Status _status = Status.NotStarted;

	public virtual void Start() {
	lock (_gate) {
	if (_status != Status.NotStarted)
	return;

	_status = Status.Starting;
	}

	StartCore();

	lock (_gate) {
	if (_status == Status.Starting) {
	_status = Status.Started;
	return;
	}
	}

	DisposeCore();
	}

	public void Dispose() {
	lock (_gate) {
	var origStatus = _status;
	_status = Status.Disposed;

	if (origStatus != Status.Started)
	return;
	}

	DisposeCore();
	}
	}

	// 在Dispose方法中，我们对_status进行标记，但只在确定Started的情况下才
	// 调用DisposeCore。同理，在Start方法中假如发现_status已经变成了Disposed，
	// 则原地调用DisposeCore销毁对象。使用这种方法，Dispose方法完全不需要做
	// 任何等待，整体等待时间极短。

	// 清晰起见，上述代码没有使用任何CAS操作，只是对于_status读写加以简单保护。
	// 假如需要的话，我们也可以把三个lock轻松修改为CAS操作，但这只是起到锦上
	// 添花的作用。

	// 有些同学一上来就搞CAS，然后发现问题之后只是简单的修补，于是代码越变越
	// 复杂。理清思路，划分好边界，处理好边界上的竞争关系，其实逻辑说到底就是
	// 这么简单.