面试重灾区之原子操作你有必要了解下

作者：说好不能打脸
原文：https://blog.csdn.net/yinwenjie/article/details/50698751

package test.thread.atomic;

import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomic {
    public static void main(String[] args) throws Exception {
        // 实例化了一个AtomicInteger类的对象atomic并定义初始值为1
        AtomicInteger atomic = new AtomicInteger(1);
        // 进行atomic的原子化操作：增加1并且获取这个增加后的新值
        atomic.incrementAndGet();
    }
}

public class AtomicInteger extends Number implements java.io.Serializable {
    ......
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();

    ......
    private volatile int value;
    ......

    /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }   

    ......

    /**
     * Atomically increments by one the current value.
     * @return the updated value
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    ......

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

public final int incrementAndGet() {
    // 一直循环的目的是为了“预期值”与“真实值”不一致的情况下，
    // 能够重新进行+1计算
    for (;;) {
        // 取得/重新取得 当前的value值
        int current = get();
        // 将当前值+1
        int next = current + 1;
        // 这是最关键的，使用JDK中实现的CAS机制
        // 对当前值和预期值进行比较
        // 如果当前值和预期的不一样，说明有某一个其他线程完成了值的更改
        // 那么进行下一次循环，进行重新操作（因为之前的操作结果就不对了）
        if (compareAndSet(current, next))
            return next;
    }
}

package test.thread.atomic;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class TestAtomicArray {
    public static void main(String[] args) throws Exception {
        AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
        // 设置指定索引位的数值
        atomicArray.set(0, 5);

        // 您也可以通过以下方法设置
        //（实际上默认值为0，这里加了5）
        // atomicArray.addAndGet(0, 5);

        // --
        int current = atomicArray.decrementAndGet(0);
        System.out.println("current = " + current);
    }
}

public class AtomicIntegerArray implements java.io.Serializable {
    ......
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final int base = unsafe.arrayBaseOffset(int[].class);
    ......

    private final int[] array;

    ......

    /**
     * Creates a new AtomicIntegerArray of the given length, with all
     * elements initially zero.
     *
     * @param length the length of the array
     */
    public AtomicIntegerArray(int length) {
        array = new int[length];
    }

    ......

    /**
     * Atomically decrements by one the element at index {@code i}.
     *
     * @param i the index
     * @return the updated value
     */
    public final int decrementAndGet(int i) {
        return addAndGet(i, -1);
    }

    ......

    public final int addAndGet(int i, int delta) {
        long offset = checkedByteOffset(i);
        while (true) {
            int current = getRaw(offset);
            int next = current + delta;
            if (compareAndSetRaw(offset, current, next))
                return next;
        }
    }
}

/**
 * 代表学生的Student类
 * @author yinwenjie
 */
class Student {
    /**
     * 学生成绩
     */
    private Performance performance;
    /**
     * 学生姓名
     */
    private String name;

    public Student(String name , Integer performance) {
        this.name = name;
        this.performance = new Performance();
        this.performance.setPerformance(performance);
    }

    /**
     * @return the performance
     */
    public Performance getPerformance() {
        return performance;
    }
    /**
     * @param performance the performance to set
     */
    public void setPerformance(Performance performance) {
        this.performance = performance;
    }
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 代表着学生成绩
 * @author yinwenjie
 */
class Performance {
    /**
     * 成绩属性是一个整数
     */
    private Integer performance;

    /**
     * @return the performance
     */
    public Integer getPerformance() {
        return performance;
    }

    /**
     * @param performance the performance to set
     */
    public void setPerformance(Integer performance) {
        this.performance = performance;
    }
}

public static void main(String[] args) throws RuntimeException {
    Student student = new Student("yinwenjie" , 80);
    AtomicReference<Student> ref = new AtomicReference<Student>(student);

    student = new Student("yinwenjie" , 70);
    Student oldStudent = ref.getAndSet(student);

    System.out.println(student + "和" + oldStudent + "是两个对象");
    System.out.println("AtomicReference保证了赋值时的原子操作性");
}

public class Student {
    ......
    /**
     * 学生成绩
     */
    private volatile Performance performance;

    /**
     * 学生成绩“更改者”
     */
    // 会重点讲解关于“更改器”的参数问题
    private AtomicReferenceFieldUpdater<Student, Performance> performance_updater = 
    AtomicReferenceFieldUpdater.newUpdater(Student.class, Performance.class, "performance");
    ......

    /**
     * @return the performance
     */
    public Performance getPerformance() {
        return performance;
    }

    /**
     * @param performance the performance to set
     */
    public void setPerformance(Performance performance) {
        // 注意，这里设置的是updater，而不是直接设置performance属性
        performance_updater.set(this, performance);
    }

    ......
}

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

    Student student = new Student();
    Performance newPerformance = new Performance();
    newPerformance.setPerformance(80);
    // 注意，这样student中的performance属性
    // 就是用了乐观机制，保证了操作的线程安全性
    student.setPerformance(newPerformance);

    // 再设置一次
    Performance otherPerformance = new Performance();
    otherPerformance.setPerformance(100);
    student.setPerformance(otherPerformance);
    System.out.println("student还是一个");
    System.out.println(newPerformance + "和" + otherPerformance + "不一样了");
}