volalite 可见性和原子性

在自己写的一个爬虫项目中，爬虫会根据采集的链接不断继续爬行下去，这个时候设置了一个开关 stop，当 stop = true 时，爬虫就会停止爬取。

我写了一个接口来控制这个 stop 字段，发现不会立即停止。
于是想到了 关于 volatile 的特性，那么实现可见性和原子性有的方式目前总结了三种：

public class VolatileTest {

    /**
     * done 这个类不能保证可见性，可能会读取到旧值
     * 
     * @author apple
     */
    static final class ControllerStop extends Thread {

        private boolean done = false;

        public void run() {
            while (!done) {
                try {
                    Thread.currentThread().sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        public void shutdown() {
            done = true;
        }

    }

    /**
     * 使用 volatile 保证可见性
     * 
     * @author apple
     */
    static final class ControllerStopV1 extends Thread {

        private volatile boolean done = false;

        public void run() {
            while (!done) {
                try {
                    Thread.currentThread().sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        public void shutdown() {
            done = true;
        }

    }

    /**
     * 使用原子类 AtomicBoolean 保证可见性
     * 
     * @author apple
     */
    static final class ControllerStopV2 extends Thread {

        private AtomicBoolean done = new AtomicBoolean(false);

        public void run() {
            while (!done.get()) {
                try {
                    Thread.currentThread().sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        public void shutdown() {
            done.set(true);
        }

    }

    /**
     * 使用原子类 AtomicBoolean 保证可见性
     * 
     * @author apple
     */
    static final class ControllerStopV3 extends Thread {

        private boolean done = false;

        public void run() {
            while (!done) {
                try {
                    Thread.currentThread().sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        public synchronized void shutdown() {
            done = true;
        }

    }

}

volatile 只能确保可见性，但是不能保证原子性，比如：

public class A {
	private volatile int value;
	public int getValue() {
		return value;
	}
	public void incr() {
		value++;
	}
}

虽然只是简单的 value++ 但是其操作是 value = value + 1

1. 读取value
2. value + 1
3. 写入 value = value + 1

volatile 并不能保证其原子性。