1 public class Counter {

 2     private int value;

 3

 4     public synchronized int getValue() {

 5         return value;

 6     }

 7

 8     public synchronized int increment() {

 9         return ++value;

10     }

11

12     public synchronized int decrement() {

13         return --value;

14     }

15 }

 1 public class SimpleCAS {

 2     private volatile int value;

 3     public synchronized int getValue(){

 4         return value;

 5     }

 6     public synchronized boolean comperaAndSwap(int expectedValue,int newValue){

 7         int oldValue = value;

 8         if(oldValue == expectedValue){

 9             value = newValue;

10             return true;

11         }else{

12             return false;

13         }

14     }

15 }

 1 public class CASCounter {

 2     private SimpleCAS cas;

 3     public int getValue(){

 4         return cas.getValue();

 5     }

 6     public int increment(){

 7         int olevalue = cas.getValue();

 8         for (; ;) {

 9             if(cas.comperaAndSwap(olevalue, olevalue+1)){

10                 return cas.getValue();

11             }

12         }

13

14     }

15 }

/*

 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 */

/*

 *

 *

 *

 *

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

package java.util.concurrent.atomic;

import sun.misc.Unsafe;

/**

 * An {@code int} value that may be updated atomically.  See the

 * {@link java.util.concurrent.atomic} package specification for

 * description of the properties of atomic variables. An

 * {@code AtomicInteger} is used in applications such as atomically

 * incremented counters, and cannot be used as a replacement for an

 * {@link java.lang.Integer}. However, this class does extend

 * {@code Number} to allow uniform access by tools and utilities that

 * deal with numerically-based classes.

 *

 * @since 1.5

 * @author Doug Lea

*/

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;//value值的偏移地址

    static {

      try {

        valueOffset = unsafe.objectFieldOffset

            (AtomicInteger.class.getDeclaredField("value"));

      } catch (Exception ex) { throw new Error(ex); }

    }

    private volatile int value;//实际的值

    /**

     * Creates a new AtomicInteger with the given initial value.

     *

     * @param initialValue the initial value

     */

    public AtomicInteger(int initialValue) {

        value = initialValue;//初始化

    }

    /**

     * Creates a new AtomicInteger with initial value {@code 0}.

     */

    public AtomicInteger() {

    }

    /**

     * Gets the current value.

     *

     * @return the current value

     */

    public final int get() {

        return value;//返回value值

    }

    /**

     * Sets to the given value.

     *

     * @param newValue the new value

     */

    public final void set(int newValue) {

        value = newValue;//设置新值,因为没有判断oldvalue，所以此操作是非线程安全的

    }

    /**

     * Eventually sets to the given value.

     *

     * @param newValue the new value

     * @since 1.6

     */

    public final void lazySet(int newValue) {

        unsafe.putOrderedInt(this, valueOffset, newValue);//与set操作效果一样，只是采用的是unsafe对象中通过偏移地址来设置值的方式

    }

    /**

     * Atomically sets to the given value and returns the old value.

     *

     * @param newValue the new value

     * @return the previous value

     */

    public final int getAndSet(int newValue) {//原子操作，设置新值，返回老值

        for (;;) {

            int current = get();

            if (compareAndSet(current, newValue))//通过CAS算法，比较current的值和实际值是否一致，如果一致则设置为newValue

                return current;

        }

    }

    /**

     * 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);

    }

    /**

     * Atomically sets the value to the given updated value

     * if the current value {@code ==} the expected value.

     *

     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>

     * and does not provide ordering guarantees, so is only rarely an

     * appropriate alternative to {@code compareAndSet}.

     *

     * @param expect the expected value

     * @param update the new value

     * @return true if successful.

     */

    public final boolean weakCompareAndSet(int expect, int update) {

        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

    }

    /**

     * Atomically increments by one the current value.

     *

     * @return the previous value

     */

    public final int getAndIncrement() {//i++操作

        for (;;) {

            int current = get();//获取当前值

            int next = current + 1;//当前值+1

            if (compareAndSet(current, next))//比较current值和实际的值是否一致，如不一致，则继续循环

                return current;

        }

    }

    /**

     * Atomically decrements by one the current value.

     *

     * @return the previous value

     */

    public final int getAndDecrement() {

        for (;;) {

            int current = get();

            int next = current - 1;

            if (compareAndSet(current, next))

                return current;

        }

    }

    /**

     * Atomically adds the given value to the current value.

     *

     * @param delta the value to add

     * @return the previous value

     */

    public final int getAndAdd(int delta) {//例如：当我们统计接口的响应时间时，可以利用此方法

        for (;;) {

            int current = get();

            int next = current + delta;

            if (compareAndSet(current, next))

                return current;

        }

    }

    /**

     * 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 decrements by one the current value.

     *

     * @return the updated value

     */

    public final int decrementAndGet() {

        for (;;) {

            int current = get();

            int next = current - 1;

            if (compareAndSet(current, next))

                return next;

        }

    }

    /**

     * Atomically adds the given value to the current value.

     *

     * @param delta the value to add

     * @return the updated value

     */

    public final int addAndGet(int delta) {

        for (;;) {

            int current = get();

            int next = current + delta;

            if (compareAndSet(current, next))

                return next;

        }

    }

    /**

     * Returns the String representation of the current value.

     * @return the String representation of the current value.

     */

    public String toString() {

        return Integer.toString(get());

    }

    public int intValue() {

        return get();

    }

    public long longValue() {

        return (long)get();

    }

    public float floatValue() {

        return (float)get();

    }

    public double doubleValue() {

        return (double)get();

    }

}

AtomicStampedReference解决ABA问题

在运用CAS做Lock-Free操作中有一个经典的ABA问题：

线程1准备用CAS将变量的值由A替换为B，在此之前，线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。但实际上这时的现场已经和最初不同了，尽管CAS成功，但可能存在潜藏的问题，例如下面的例子：

现有一个用单向链表实现的堆栈，栈顶为A，这时线程T1已经知道A.next为B，然后希望用CAS将栈顶替换为B：

head.compareAndSet(A,B);

在T1执行上面这条指令之前，线程T2介入，将A、B出栈，再pushD、C、A，此时堆栈结构如下图，而对象B此时处于游离状态：

此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null，所以此时的情况变为：

其中堆栈中只有B一个元素，C和D组成的链表不再存在于堆栈中，平白无故就把C、D丢掉了。

以上就是由于ABA问题带来的隐患，各种乐观锁的实现中通常都会用版本戳version来对记录或对象标记，避免并发操作带来的问题，在Java中，AtomicStampedReference<E>也实现了这个作用，它通过包装[E,Integer]的元组来对对象标记版本戳stamp，从而避免ABA问题，例如下面的代码分别用AtomicInteger和AtomicStampedReference来对初始值为100的原子整型变量进行更新，AtomicInteger会成功执行CAS操作，而加上版本戳的AtomicStampedReference对于ABA问题会执行CAS失败：

public class Test {

private static AtomicInteger atomicInt = new AtomicInteger(100);

private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(100, 0);

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

Thread intT1 = new Thread(new Runnable() {

@Override

public void run() {

atomicInt.compareAndSet(100, 101);

atomicInt.compareAndSet(101, 100);

}

});

Thread intT2 = new Thread(new Runnable() {

@Override

public void run() {

try {

TimeUnit.SECONDS.sleep(1);

} catch (InterruptedException e) {

}

boolean c3 = atomicInt.compareAndSet(100, 101);

System.out.println(c3); // true

}

});

intT1.start();

intT2.start();

intT1.join();

intT2.join();

Thread refT1 = new Thread(new Runnable() {

@Override

public void run()

try {

TimeUnit.SECONDS.sleep(1);

} catch (InterruptedException e) {

}

atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);

atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);

}

});

Thread refT2 = new Thread(new Runnable() {

@Override

public void run() {

int stamp = atomicStampedRef.getStamp();

try {

TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

}

boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);

System.out.println(c3); // false

}

});

refT1.start();

refT2.start();

}

}