Java Volatile 关键字

volatile

我们在代码中开启一个线程之后，想要依据某些条件去控制线程是否结束的时候，可以通过定义一个 volatile 关键字修饰的变量去进行操作。示例代码如下：

public class RunThread extends Thread {

    private volatile boolean isRunning;

    public void setRunning(boolean running) {
        isRunning = running;
    }

    @Override
    public void run() {
        System.out.println("进入线程。。。");
        while (isRunning) {
            // do something
        }
        System.out.println("线程结束");
    }

    public static void main(String[] arg0) throws InterruptedException {
        RunThread t1 = new RunThread();
        t1.start();
        Thread.sleep(3000);
        t1.setRunning(false);
        Thread.sleep(1000);
        System.out.println("t1 isRunnung : " + t1.isRunning);
    }
}

打印结果：

结果正常，没毛病。
那么我们多个线程调用呢？是否还能达到预期效果？我们来试一下：

public class RunThread1 extends Thread {

    private static volatile int count;

    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println(count);
    }

    @Override
    public void run() {
        addCount();
    }

    public static void main(String[] arg0) {
        RunThread1[] ts = new RunThread1[10];
        for (int i = 0; i < 10; i++) {
            ts[i] = new RunThread1();
        }

        for (int i = 0; i < 10; i++) {
            ts[i].start();
        }
    }
}

运行结果：

正常来说，我们最终的结果肯定要是 10000 才是正常的，但是这个输出的结果，明显与我们的预期不相符。

验证结果：volatile 线程间可见性，非原子性，属于线程不安全。

Atomic

那么如果我们上面的多线程调用情况我们要怎么办呢？ 这里提供一种写法：

public class RunThread2 extends Thread {

    private static AtomicInteger count = new AtomicInteger();

    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count.getAndIncrement();
        }
        System.out.println(count);
    }

    @Override
    public void run() {
        addCount();
    }

    public static void main(String[] arg0) {
        RunThread2[] ts = new RunThread2[10];
        for (int i = 0; i < 10; i++) {
            ts[i] = new RunThread2();
        }

        for (int i = 0; i < 10; i++) {
            ts[i].start();
        }
    }
}

打印结果：

最终输出结果，是不是有 10000 了， 有时候编译器有些延迟，但是不影响我们每次的打印结果都有 10000 。

这里简略的介绍一下 Atomic 包：Java从JDK1.5开始提供了java.util.concurrent.atomic包，方便程序员在多线程环境下，无锁的进行原子操作。原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞。

当然 Atomic 包中还有其他原子更新方式，比如 AtomicBoolean ， AtomicLong ， AtomicIntegerArray ， AtomicLongArray ， AtomicReferenceArray.. 等等。有需要的还请各位自行 Google.

学习笔记整理。