06 java.util.concurrent——Atomic

概述

1、Atomic是为 属性提供原子性操作的相关的类，对外提供了大量的线程安全的方法来使用，底层保证线程安全的是采用了CAS算法。
2、保证原子性的属性，例如有AutomicInteger原子型整型，AutomicBoolean原子型布尔类型
3、原子型的属性实际开发中并不常用

AutomicInteger

当使用普通的int类型，并且没有任何的同步机制，或者锁机制的话，下面的代码存在线程安全问题。
原因在于获取ai的值，以及给ai加1赋值给ai不是一个原子型的操作，可能线程A刚获取了ai的值，就被线程B抢占了。

package atomic;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerDemo {
     static int ai = 0;
    public static void main(String[] args) throws InterruptedException {


        CountDownLatch cdl = new CountDownLatch(2);
        new Thread(new Add(cdl)).start();
        new Thread(new Add(cdl)).start();
        // 上面累加完成之后，才能打印i的值
        cdl.await();
        System.out.println(ai);
    }
}

class Add implements Runnable {

    private CountDownLatch cdl;

    public Add(CountDownLatch cdl) {
        this.cdl = cdl;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
             AtomicIntegerDemo.ai++;
        }
        cdl.countDown();
    }
}

将int类型的ai修改为原子操作类型，同样不同加锁或者同步，也能够保证线程安全了
AutomicInteger
getAndIncrement() 相当于++操作

package atomic;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerDemo {

    static AtomicInteger ai = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {


        CountDownLatch cdl = new CountDownLatch(2);
        new Thread(new Add(cdl)).start();
        new Thread(new Add(cdl)).start();
        // 上面累加完成之后，才能打印i的值
        cdl.await();
        System.out.println(ai);

    }



}

class Add implements Runnable {

    private CountDownLatch cdl;

    public Add(CountDownLatch cdl) {
        this.cdl = cdl;
    }

    @Override
    public void run() {

        for (int i = 0; i < 1000000; i++) {
            AtomicIntegerDemo.ai.getAndIncrement();
        }
        cdl.countDown();
    }
}

volatile

在实际的开发过程中，Atomic往往会结合volatile来使用
volatile是Java提供一个线程之间的轻量级的同步机制
例如i++这样的操作

volatile的作用

保证内存可见性
执行下面的代码：当B线程修改了堆内存中对象的值以后，线程A是否感知到了变化？

package atomic;

public class VolatileDemo {

    public static void main(String[] args) {

        Data d = new Data();
        d.i = 10;

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("A线程启动了");
                while (d.i == 10) ;
                System.out.println("i的值被改变，i现在不是10了");
                System.out.println("A线程结束了");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("B线程启动了");
                    Thread.sleep(3000);
                    d.i = 50;
                    System.out.println("B线程结束了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

}

class Data {
	//volatile int i;
    int i;
}

事实上，A线程并不能监视到这种变量值的改变，B线程结束之后，A线程还在运行。
在Data类的属性i前面添加volatile关键字以后，程序运行正常。
也就说，当属性值加上volatile关键字时，当一个线程改变数据之后，其他线程能立即感知到数据的变化。

A线程和B线程都有自己的栈内存，i的值时存储在自己的栈内存中的，要么线程A主动修改堆内存中的值，要么堆内存通知A线程值已修改，否则的话A线程是感知不到堆内存中i属性的变化的（由线程B修改导致的）。加上volatile关键字，某个线程修改了值，会主动通知其他线程值已被修改。

B线程将i的值拷贝到自己的栈内存中进行运算，修改成50之后，B线程执行结束后会把i的值更新会堆内存中。

不保证原子性
也就是说 volatile不保证线程安全。当一个线程执行操作，如果能够保证这个线程的操作是不可分割或者不能打断的，就能保证这个线程操作数据时完整的，操作是原子的，才能保证线程安全。volatile做不到。

"如果volatile能够保证线程安全的话，最后的执行结果应该是20000，实际上不是"

package atomic;

public class VolatileDemo2 {


    public static void main(String[] args) throws InterruptedException {

        Data d = new Data();
        d.i = 0;
        new Thread(new Sum(d)).start();
        new Thread(new Sum(d)).start();

        Thread.sleep(3000);
        // 如果volatile保证原子性(保证线程安全)，那么累加的结果应该是20000
        System.out.println(d.i);

    }
}


class Sum implements Runnable {

    private Data d;

    public Sum(Data d) {
        this.d = d;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            d.i++;
        }
    }
}

class Data{
	volatile int i;
}

禁止指令重排
指令重排发生的概率极小。
指令重排是指，由于优化的原因，指令的实际执行顺序可能和我们程序的书写顺序不一样。
指令重排可能会发生在多个地方。

即使是指令重排，也不会违背数据的依赖性(如果使用这个数据，这个数据必须前面先出现) ；但单线程的环境下，指令重排也不会影响 串行语义，也就是说，指令重排不是乱排，单线程的环境下是一定不会导致结果出错的，而指令重排是为了提高效率。

但是在多线程的环境下，不改变单线程中的串行语义，不代表不会对多线程造成影响。有可能由于指令重排而导致最后的结果出现不一致的情况。

这个例子不太恰当。但指令重排是怎么个意思。