Java的原子类无锁并发利器详解

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        TestCount testCount = new TestCount();
        Thread T1 = new Thread(()->{
            testCount.add10k();
        });
        Thread T2 = new Thread(()->{
            testCount.add10k();
        });
        T1.start();
        T2.start();
        T1.join();
        T2.join();
        System.out.println(testCount.count);
    }
}
class TestCount{
    long count = 0;
    void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count += 1;
        }
    }
}

class TestCount{
    volatile long count = 0;
    synchronized void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count += 1;
        }
    }
}

class TestCount{
    AtomicLong count = new AtomicLong(0);
     void add10k(){
        int idx = 0;
        while (idx++ < 10000){
            count.getAndIncrement();
        }
    }
}

class SimpleCAS{
    int count;
    public synchronized int cas(int expect,int newCount){
        // 读取count值
       int oldcount = count;
       // 读取的count值和期望值比较
       if (oldcount == expect){
           count = newCount;
       }
       // 返回老值
       return oldcount;
    }
}

class SimpleCAS{
    volatile int count;
    public synchronized int cas(int expect,int newCount){
        // 读取count值
       int oldcount = count;
       // 读取的count值和期望值比较
       if (oldcount == expect){
            count = newCount;
        }
       // 返回老值
       return oldcount;
    }
    // 自旋操作，执行cas方法
    public void addOne(){
        int newCount = 0;
        do {
            newCount = count + 1;
        }while (count != cas(count,newCount));
    }
}

public static void main(String[] args) throws InterruptedException {
    // 初始化原子类 定义初始引用和标识
    // AtomicMarkableReference同理可得，只是将版本戳换成了boolean类型
    AtomicStampedReference<String> reference = new AtomicStampedReference<>("zhangsan",1001);
    /**
      * expectedReference 期望的引用
      * newReference     新的引用
      * expectedStamp    期望的版本戳
      * newStamp         新的版本戳
      * 只有当期望引用和期望版本戳都符合实际版本戳和引用才能替换成功
    */
    reference.compareAndSet("zhangsan","lisi",1002,1003);
    // zhangsan 替换失败的原因是期望版本戳和实际版本戳不匹配
    System.out.println(reference.getReference());
    reference.compareAndSet("zhangsan","lisi",1001,1002);
    // lisi 替换成功
    System.out.println(reference.getReference());
    reference.compareAndSet("lisi1","wangwu",1002,1003);
    // lisi 替换失败的原因是期望引用和实际引用不匹配
    System.out.println(reference.getReference());
}

/**
  * this 指当前对象
  * valueOffset 指内存地址偏移量
*/
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
  * this 指当前对象
  * valueOffset 指内存地址偏移量
*/
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        // 就是读取主内存的值
        var5 = this.getIntVolatile(var1, var2);
        // this.compareAndSwapInt方法就是对应上诉的cas方法，不过返回值是boolean类型
        // var5读取的主内存值
        // 更新成功返回true，跳出循环
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}