Java 使用AtomicInteger实现锁，即无锁编程代码实现

待我称王封你为后i 2023-05-29 05:12 23阅读 0赞

### 1. 原子操作 ###

多线程并发编程中，容易出现并发安全问题；举一简单的例子，多线程更新变量i=1,比如多个线程执行i++操作，就有可能获取不到预期的正确值，而这个问题，最常用的方法是通过Synchronized或者ReentrantLock进行控制来达到线程安全的目的。然而，synchronized采用的是悲观锁策略，并非特别高效的一种解决方案。实际上，在J.U.C下的atomic包提供了一系列的操作简单，性能高效，并能保证线程安全的类去更新基本类型变量，数组元素，引用类型以及更新对象中的字段类型。atomic包下的这些类都是采用的是乐观锁策略去原子更新数据，在java中则是使用CAS操作具体实现。

### 2. CAS操作 ###

**CAS操作**

Java中使用锁，线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以**当前线程获取到锁的时候同时也会阻塞其他线程获取该锁**。CAS操作（亦称无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时不会出现冲突，既然不会出现冲突自然而然就不会阻塞其他线程的操作。因此，线程就不会出现阻塞停顿的状态。那么，如果出现冲突了怎么办？无锁操作是使用CAS(compare and swap)又叫做比较交换来鉴别线程是否出现冲突，出现冲突就重试当前操作直到没有冲突为止。

**CAS的操作详述**

CAS比较交换的过程可以通俗的理解为CAS(V,O,N)，包含三个值分别为：V 内存地址存放的实际值；O 预期的值（旧值）；N 更新的新值。当V和O相同时，也就是说旧值和内存中实际的值相同表明该值没有被其他线程更改过，即该旧值O就是目前来说最新的值了，自然而然可以将新值N赋值给V。反之，V和O不相同，表明该值已经被其他线程改过了则该旧值O不是最新版本的值了，所以不能将新值N赋给V，返回V即可。当多个线程使用CAS操作一个变量是，只有一个线程会成功，并成功更新，其余会失败。失败的线程会重新尝试，当然也可以选择挂起线程

CAS的实现需要硬件指令集的支撑，在JDK1.5后虚拟机才可以使用处理器提供的CMPXCHG指令实现。

**Synchronized VS CAS**

元老级的Synchronized(未优化前)最主要的问题是：在存在线程竞争的情况下会出现线程阻塞和唤醒锁带来的性能问题，因为这是一种互斥同步（阻塞同步）。而CAS并不是武断的间线程挂起，当CAS操作失败后会进行一定的尝试，而非进行耗时的挂起唤醒的操作，因此也叫做非阻塞同步。这是两者主要的区别。

**CAS的问题**

1.  ABA问题  
    因为CAS会检查旧值有没有变化，这里存在这样一个有意思的问题。比如一个旧值A变为了成B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了变化。解决方案可以沿袭数据库中常用的乐观锁方式，添加一个版本号可以解决。原来的变化路径A->B->A就变成了1A->2B->3C。
2.  自旋时间过长

使用CAS时非阻塞同步，也就是说不会将线程挂起，会自旋（无非就是一个死循环）进行下一次尝试，如果这里自旋时间过长对性能是很大的消耗。如果JVM能支持处理器提供的pause指令，那么在效率上会有一定的提升。

### 3. 原子更新基本类型 ###

atomic包提高原子更新基本类型的工具类，主要有这些：

1.  **AtomicBoolean**：以原子更新的方式更新boolean；
2.  **AtomicInteger**：以原子更新的方式更新Integer;
3.  **AtomicLong**：以原子更新的方式更新Long；

这几个类的用法基本一致，这里以AtomicInteger为例总结常用的方法

1.  addAndGet(int delta) ：以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果；
2.  incrementAndGet() ：以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果；
3.  getAndSet(int newValue)：将实例中的值更新为新值，并返回旧值；
4.  getAndIncrement()：以原子的方式将实例中的原值加1，返回的是自增前的旧值；

还有一些方法，可以查看API，不再赘述。为了能够弄懂AtomicInteger的实现原理，以getAndIncrement方法为例，来看下源码：

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

可以看出，该方法实际上是调用了unsafe实例的getAndAddInt方法，unsafe实例的获取时通过UnSafe类的静态方法getUnsafe获取：

private static final Unsafe unsafe = Unsafe.getUnsafe();

Unsafe类在sun.misc包下，Unsafer类提供了一些底层操作，atomic包下的原子操作类的也主要是通过Unsafe类提供的compareAndSwapInt，compareAndSwapLong等一系列提供CAS操作的方法来进行实现。下面用一个简单的例子来说明AtomicInteger的用法：

public class AtomicDemo {
        private static AtomicInteger atomicInteger = new AtomicInteger(1);
    
        public static void main(String[] args) {
            System.out.println(atomicInteger.getAndIncrement());
            System.out.println(atomicInteger.get());
        }
    }
    输出结果：
    1
    2

例子很简单，就是新建了一个atomicInteger对象，而atomicInteger的构造方法也就是传入一个基本类型数据即可，对其进行了封装。对基本变量的操作比如自增，自减，相加，更新等操作，atomicInteger也提供了相应的方法进行这些操作。但是，因为atomicInteger借助了UnSafe提供的CAS操作能够保证数据更新的时候是线程安全的，并且由于CAS是采用乐观锁策略，因此，这种数据更新的方法也具有高效性。

AtomicLong的实现原理和AtomicInteger一致，只不过一个针对的是long变量，一个针对的是int变量。而boolean变量的更新类AtomicBoolean类是怎样实现更新的呢?核心方法是`compareAndSet`t方法，其源码如下：

public final boolean compareAndSet(boolean expect, boolean update) {
        int e = expect ? 1 : 0;
        int u = update ? 1 : 0;
        return unsafe.compareAndSwapInt(this, valueOffset, e, u);
    }

可以看出，compareAndSet方法的实际上也是先转换成0,1的整型变量，然后是通过针对int型变量的原子更新方法compareAndSwapInt来实现的。可以看出atomic包中只提供了对boolean,int ,long这三种基本类型的原子更新的方法，参考对boolean更新的方式，原子更新char,doule,float也可以采用类似的思路进行实现。

### 4、锁的自实现 ###

4.1代码实现

package com.casLock;
    
    /**
     * Java 借用AtomicInteger实现同步锁
     * 类比ReentrantLock
     *
     * @author liuxd
     * @version 1.0
     * @date 2019-11-04 15:00
     */
    
    import java.util.concurrent.ConcurrentLinkedQueue;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.LockSupport;
    
    public class IConcurrentLock implements Lock {
        //初始化为 0
        private AtomicInteger atomicInteger = new AtomicInteger(0);
        private ConcurrentLinkedQueue<Thread> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
    
        /**
         * 上锁
         */
        @Override
        public void lock() {
            if (atomicInteger.compareAndSet(0, 1)) {
                return;
            }
    
            //首先，将当前线程放置等待队列中
            concurrentLinkedQueue.add(Thread.currentThread());
    
            //自旋_死等
            while (true) {
                if (0 == atomicInteger.get()) {
                    //期望是0，是0返回true，否则加1并返回false
                    if (atomicInteger.compareAndSet(0, 1)) {
                        concurrentLinkedQueue.remove(Thread.currentThread());
                        return;
                    }
                } else {
                    //挂起当前线程
                    LockSupport.park();
                }
            }
        }
    
        /**
         * 解锁
         */
        @Override
        public void unlock() {
            atomicInteger.set(0);
            //唤醒等待队列的第一个线程
            Thread waiterHead = concurrentLinkedQueue.peek();
            if (null != waiterHead) {
                //唤醒线程
                LockSupport.unpark(waiterHead);
            }
        }
    
        @Override
        public void lockInterruptibly() throws InterruptedException {
    
        }
    
        @Override
        public boolean tryLock() {
            return false;
        }
    
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return false;
        }
    
        @Override
        public Condition newCondition() {
            return null;
        }
    }

### 2、验证 ###

package com.casLock;
    
    /**
     * @author liuxd
     * @version 1.0
     * @date 2019-11-04 15:02
     */
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    public class NoAtomicOperationDemo {
        static long count = 0;
    
        public static void add() {
            count++;
        }
    
        public static void main(String[] args) {
            NoAtomicOperationDemo.AtomicIntShow();
        }
    
        /**
         * 开启多个线程进行自加加操作
         * 赘述:多个线程必须共用一把锁*
         */
        public static void AtomicIntShow() {
            /**
             * jdk中ReentrantLock
             */
    //       Lock lock = new ReentrantLock();
            /**
             * 使用 AtomicInteger 自实现的锁
             */
            Lock lock = new IConcurrentLock();
            System.out.println("启动...");
            ExecutorService threadpool = Executors.newFixedThreadPool(10);
    
            for (int k = 0; k < 100; k++) {
                threadpool.submit(new AddThread(lock));
            }
    
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("result of acumulated sum=" + count);
            threadpool.shutdown();
            System.out.println("AtomicIntShow() exit");
            return;
    
        }
    
        /**
         * 执行调用的线程
         */
        public static class AddThread implements Runnable {
            Lock lock;
    
            public AddThread() {
            }
    
            public AddThread(Lock lock) {
                this.lock = lock;
            }
    
            public void run() {
                for (int k = 0; k < 1000; k++) {
                    lock.lock();
                    try {
                        NoAtomicOperationDemo.add();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
    
                }
            }
        }
    
    
    }

结果：

启动...
    result of acumulated sum=100000
    AtomicIntShow() exit

> 说明:
> 
>         本文，并未将线程设置为循环等待，获取到锁后，执行，获取不到，则放入队列并挂起，毕竟循环等待对CPU也是一种开销。本文旨在讲解什么是CAS操作，以及如何使用CAS实现锁的，并给出代码验证示例和验证结果。
> 
>         本文部分内容取自网络，因整理过程中，忘记记录出处。
> 
>