Java程序员面试之并发进阶(补充），Atomic、ThreadLocal、AQS

Love The Way You Lie 2021-11-14 12:30 303阅读 0赞

本文主要参考Java面试进阶指南（[https://xiaozhuanlan.com/topic/6149802735][https_xiaozhuanlan.com_topic_6149802735]）

不足之处，欢迎大家批评指正！

本文主要内容：

*  Atomic原子类
 *  ThreadLocal
 *  AQS

### 一、Atomic ###

1.介绍下Atomic原子类

原子性指：一个操作不能被再拆分了；即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。原子类就是具有原子/原子操作特征的类。

jdk提供的原子类：

![70][]

2.JUC 包中的原子类是哪 4 类?

基本类型：使用原子方式封信基本类型

AtomicInteger：整形原子类、AtomicLong：长整形原子类、AtomicBoolean：布尔型原子类

数组类型：使用原子方式更新数组里的某个元素

AtomicIntegerArray、AtomicIntegerArray、AtomicReferenceArray:引用类型数组原子类

引用类型： AtomicReference：引用类型原子类、AtomicStampedRerence：原子更新引用类型里的字段原子类

AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型：AtomicIntegerFieldUpdater:原子更新整形字段的更新器

AtomicLongFieldUpdater:原子更新长整形字段的更新器

AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决                                      原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

3.AtomicInterger的使用？

AtomicInteger 类常用方法：

public final int get() //获取当前的值
    public final int getAndSet(int newValue)//获取当前的值，并设置新的值
    public final int getAndIncrement()//获取当前的值，并自增
    public final int getAndDecrement() //获取当前的值，并自减
    public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
    boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
    public final void lazySet(int newValue)//最终设置为 newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

使用示例：

//使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。
    class AtomicIntegerTest {
            private AtomicInteger count = new AtomicInteger();
          //使用 AtomicInteger 之后，不需要对该方法加锁，也可以实现线程安全。
            public void increment() {
                      count.incrementAndGet();
            }
    
           public int getCount() {
                    return count.get();
            }
    }

4.介绍一下 AtomicInteger 类的原理

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS算法保证数据变量的原子性，CAS算法是硬件对于并发操作的支持，CAS包含了三个操作数：

①内存值  V ②预估值  A ③更新值  B

当且仅当 V == A 时， V = B; 否则，不会执行任何操作。

### 二、ThreadLocal ###

1.ThreadLocal是什么？

ThreadLocal是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不通的变量值完成操作的场景。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就像是线程的本地变量，这也是类名中“Local”所要表达的意思。

2.ThreadLocal示例

public class TestNum {  
        // ①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值  
        private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>() {  
            public Integer initialValue() {  
                return 0;  
            }  
        };  
      
        // ②获取下一个序列值  
        public int getNextNum() {  
            seqNum.set(seqNum.get() + 1);  
            return seqNum.get();  
        }  
      
        public static void main(String[] args) {  
            TestNum sn = new TestNum();  
            // ③ 3个线程共享sn，各自产生序列号  
            TestClient t1 = new TestClient(sn);  
            TestClient t2 = new TestClient(sn);  
            TestClient t3 = new TestClient(sn);  
            t1.start();  
            t2.start();  
            t3.start();  
        }  
      
        private static class TestClient extends Thread {  
            private TestNum sn;  
      
            public TestClient(TestNum sn) {  
                this.sn = sn;  
            }  
      
            public void run() {  
                for (int i = 0; i < 3; i++) {  
                    // ④每个线程打出3个序列值  
                    System.out.println("thread[" + Thread.currentThread().getName() + "] --> sn["  
                             + sn.getNextNum() + "]");  
                }  
            }  
        }  
    }

输出：

thread[Thread-0] --> sn[1]
    thread[Thread-1] --> sn[1]
    thread[Thread-2] --> sn[1]
    thread[Thread-1] --> sn[2]
    thread[Thread-0] --> sn[2]
    thread[Thread-1] --> sn[3]
    thread[Thread-2] --> sn[2]
    thread[Thread-0] --> sn[3]
    thread[Thread-2] --> sn[3]

考察输出的结果信息，我们发现每个线程所产生的序号虽然都共享同一个TestNum实例，但它们并没有发生相互干扰的情况，而是各自产生独立的序列号，这是因为我们通过ThreadLocal为每一个线程提供了单独的副本。

3.ThreadLocal原理

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map（`ThreadLocalMap，ThreadLocalMap是ThreadLocal的静态内部类`），用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。

4.ThreadLocal内存泄漏问题

由于ThreadLocalMap的key是弱引用，而Value是强引用。这就导致了一个问题，ThreadLocal在没有外部对象强引用时，发生GC时弱引用Key会被回收，而Value不会回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 `set()`、`get()`、`remove()` 方法的时候，会清理掉 key 为 null 的记录。使用完 `ThreadLocal`方法后 最好手动调用`remove()`方法。

### 三、AQS ###

1.AQS介绍

AQS是AbstractQueuedSynchronizer的简称。AQS是提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架。比如 ReentrantLock，Semaphore， ReentrantReadWriteLock，SynchronousQueue，FutureTask 等等皆是基于 AQS 的。我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。

2.AQS原理分析

(1).原理概述

AQS 核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到锁的线程加入到队列中。原理图如下：

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81MzcyNy1hZTM2ZGI1ODI0MWMyNTZiLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvODUyL2Zvcm1hdC93ZWJw][]

AQS维护了一个volatile int类型的变量，用户表示当前同步状态。state的访问方式有三种(均是原子操作)：

/**
         * The synchronization state.
         */
        private volatile int state;
      
        /**
         * Returns the current value of synchronization state.
         * This operation has memory semantics of a {@code volatile} read.
         * @return current state value
         */
        protected final int getState() {
            return state;
        }
    
        /**
         * Sets the value of synchronization state.
         * This operation has memory semantics of a {@code volatile} write.
         * @param newState the new state value
         */
        protected final void setState(int newState) {
            state = newState;
        }
    
        /**
         * Atomically sets synchronization state to the given updated
         * value if the current state value equals the expected value.
         * This operation has memory semantics of a {@code volatile} read
         * and write.
         *
         * @param expect the expected value
         * @param update the new value
         * @return {@code true} if successful. False return indicates that the actual
         *         value was not equal to the expected value.
         */
        protected final boolean compareAndSetState(int expect, int update) {
            // See below for intrinsics setup to support this
            return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
        }

(2).资源共享方式

AQS定义两种资源共享方式：

Exclusive（独占，只有一个线程能执行，如ReentrantLock），又可分为公平锁（按照线程在队列中的排队顺序，先到者先      拿到锁）和非公平锁（当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的）。

Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）：

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。

(3).AQS底层使用模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

1.  使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放）
2.  将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

自定义同步器实现时需要重写以下几种方法：

isHeldExclusively()  //该线程是否正在独占资源。只有用到condition才需要去实现它。
    tryAcquire(int)   //独占方式。尝试获取资源，成功则返回true，失败则返回false。
    tryRelease(int)   //独占方式。尝试释放资源，成功则返回true，失败则返回false。
    tryAcquireShared(int)   //共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正
                             数表示成功，且有剩余资源。
    tryReleaseShared(int)    //共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返
                                 回false。

[https_xiaozhuanlan.com_topic_6149802735]: https://xiaozhuanlan.com/topic/6149802735
[70]: /images/20211114/2d289d9cc8a546a8a1732481bf49c845.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81MzcyNy1hZTM2ZGI1ODI0MWMyNTZiLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvODUyL2Zvcm1hdC93ZWJw]: /images/20211114/5e56de28b6ac4ea6b9da3c2b53bc7caf.png