java的原子操作

原子操作

在java.util.concurrent.atomic包下提供了很多原子操作类，多个线程执行一个操作时，其中任何一个线程要么完全执行此操作，要么没有执行此操作的任何步骤，其内部使用的CAS操作 乐观锁

以AtomicInteger为例

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    // 获取当前值
    public final int get() {
        return value;
    }

    // 设置给定值
    public final void set(int newValue) {
        value = newValue;
    }

    // 延时设置
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

    // 以原子方式设置给定值，并返回旧值  线程安全版本的  tmp = oldValue;  oldValue = newValue; return oldValue
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

    // 如果当前值等于预期值，则以原子方式设置为给定的更新值，成功则返回true，失败返回false
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    // 如果当前值等于预期值，则以原子方式设置为给定的更新值，成功则返回true，失败返回false
   // 与compareAndSet方法一样
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    // 以原子方式加一 ，相当于线程安全版的i++
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    // 以原子方式减一 ，相当于线程安全版的i--
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

    // 以原子方式将给定值与当前值相加 线程安全版的i=+10  先获取再相加
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

   // 以原子方式加一 ，相当于线程安全版的++i
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

     // 以原子方式减一 ，相当于线程安全版的--i
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }

    // 以原子方式将给定值与当前值相加 线程安全版的i+=10  先相加在获取
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

}