java实现原子操作

在java中可以通过锁和循环CAS的方式实现来实现原子操作

1.使用循环CAS实现原子操作

代码如下

package com.cas;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Date: 2021/7/10
 * @Class: CasTest
 * @Description:java实现原子操作
 */
public class CasTest {
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    private int i = 0;
    public static void main(String[] args) {
        CasTest cas = new CasTest();
        List<Thread> threads = new ArrayList<>(600);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        cas.count();
                        cas.safeCount();
                    }
                }
            });
            threads.add(thread);
        }
        for (Thread thread : threads){
            thread.start();
        }
        //等待所有线程执行完成
        for (Thread thread : threads){
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicInteger.get());
        System.out.println(System.currentTimeMillis());

    }

    /**
     * 使用cas实现线程安全计数器
     */
    private void safeCount() {
        for (; ; ) {
            int i = atomicInteger.get();
            boolean suc = atomicInteger.compareAndSet(i, i++);
            if (suc) {
                break;
            }
        }
    }

    //非线程安全计数器
    private void count() {
        i++;
    }
}

2.CAS 实现原子操作的三大问题

（1） ABA 问题。
因为 CAS 需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是 A，变成了 B，又变成了 A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA 问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1、那么A→B→ A就会变成 1A → 2B → 3A。从 Java 1.5 开始，JDK 的 Atomic 包里提供了一个类AtomicSampedReference 来解决 ABA 问题。这个类的 compareAndSet 方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

  public boolean compareAndSet(){
        V       exceptedReference   //预期引用
        V       newReference        //更新后的引用
        int     exceptedStamp      // 预期标志
        int     newStamp        	//更新后的标志
    }

（2） 循环时间长开销大。
自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。如果 JVM 能支持处理器提供的 pause 指令，那么效率会有一定的提升。pause指令有两个作用:
第一，它可以延迟流水线执行指令（de-pipeline)，使 CPU 不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零；
第二，它可以避免在退出循环的时候因内存顺序冲突（Memory Order Violation）而引起 CPU 流水线被清空（CPUPipeline Flush)，从而提高 CPU 的执行效率。
（3） 只能保证一个共享变量的原子操作。
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。
从 Java 1.5 开始，JDK 提供了 AtomicReference 类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行 CAS 操作。

3.使用锁机制实现原子操作

锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。JVM 内部实现了很多种锁机制，有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁，JVM 实现锁的方式都用了循环 CAS，即当一个线程想进人同步块的时候使用循环 CAS 的方式来获取锁，岌它退出同步块的时候使用循环 CAS 释放锁。