AtomicReference，AtomicInteger，AtomicBoolean

Atomic原子家族

Atomic原子家族可保证在多线程下操作的是同一个对象，而且同一时间只有一条线程能进行操作，保证了下一条线程操作它时是最新数据。
1.AtomicReference原子引用
提供一个对象来供原子读写，可确保在多线程下操作的是同一个对象，且是同步操作。

private static User mUser;

    private void init() {
    	//引用对象mUser
        AtomicReference<User> ar = new AtomicReference<User>(mUser);

        //比较，若target和原子mUser是同一对象，用update替换它。
        ar.compareAndSet(V target, V update);
        //设置为newValue，并返回旧值
        ar.getAndSet(V newValue);
        //最终设置值，不能再变了
        ar.lazySet(V newValue);
        //设置为newValue
        ar.set(V newValue);
        //获取值
        ar.get();
    }

2.AtomicInteger
可以让类实现AtomicInteger，这样类本身就是一个AtomicInteger了，可以对类执行以下各种操作。AtomicLong用法一样。

private static int count;

    private void init() {
        AtomicInteger ai = new AtomicInteger(count);

        //比较，若target和原子count是同一对象，用update替换它。
        ai.compareAndSet(V target, V update);
        //获取当前，然后设置为newValue
        ai.getAndSet(V newValue);
        //最终设置值，不能再变了
        ai.lazySet(V newValue);
        //设置为newValue
        ai.set(V newValue);
        //获取值
        ai.get();
        //count加上预期值delta，然后获取值
        ai.addAndGet(int delta);
        //获取当前值，然后count加上预期值delta
        ai.getAndAdd(int delta);
        //自增/自减，然后获取值
        ai.incrementAndGet();
        ai.decrementAndGet();
        //获取值，然后自增/自减
        ai.getAndIncrement();
        ai.getAndDecrement();
    }

3.AtomicBoolean
可以让类实现AtomicBoolean，这样类本身就是一个AtomicBoolean了，可以对类执行以下各种操作。

private static boolean hasValue = false;

    private void init() {
        AtomicBoolean ab = new AtomicBoolean(hasValue);
        //比较，若target和原子count是同一对象，用update替换它。
        ab.compareAndSet(V target, V update);
        //获取当前，然后设置为newValue
        ab.getAndSet(V newValue);
        //最终设置值，不能再变了
        ab.lazySet(V newValue);
        //设置为newValue
        ab.set(V newValue);
        //获取值
        ab.get();
    }

先总结这三个