Java 并发概述

缺乏、安全感 2022-04-10 08:30 248阅读 0赞

**并发（Concurrency）**，是指在某个时间段内，多任务交替处理的能力。**并行（Parallelism）**，是指同一时刻同时处理多任务的能力。

在并发环境下，由于程序的封闭性被打破，出现了以下特点：

1.  并发程序之间有相互制约的关系。直接制约体现为一个程序需要另一个程序的计算结果；间接体现为多个程序竞争共享资源，如处理器、缓冲区等。
2.  并发程序的执行过程是断断续续的。程序需要记忆现场指令及执行点。
3.  当并发数设置合理并且 CPU 拥有足够的处理能力时，并发会提高程序的运行效率。

# 1. 线程安全 #

线程在声明周期内存在多种状态：

1.  新建状态（NEW）
2.  就绪状态（RUNNABLE）
3.  运行状态（RUNNING）
4.  阻塞状态（BLOCKED）
5.  终止状态（DEAD）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70]

*  **NEW，即新建状态，是线程被创建且未启动的状态**。创建线程的方式有三种：
    
    1.  继承 Thread 类。
    2.  实现 Runnable 接口。
    3.  实现 Callable 接口。

Callable 与 Runnable 有两点不同：

1.  通过 ***call()*** 获得返回值。前两种方式都有一个共同的缺陷，即在任务执行完成后，无法直接获取执行结果，需要借助共享变量等获取，而 Callable 和 Future 则很好地解决了这个问题；
2.  ***call()*** 可以抛出异常。而 Runnable 只有通过 ***setDefaultUncaughtExceptionHandler()*** 的方式才能在主线程中捕捉到子线程异常。

*  **RUNNABLE，即就绪状态，是调用 start() 之后运行之前的状态**。线程的 ***start()*** 不能被多次调用，否则会抛出 **IllegalStateException** 异常。
 *  **RUNNING，即运行状态，是 run() 正则执行时线程的状态**。线程可能会由于某些因素而退出 RUNNING，如时间、异常、锁、调度等。
 *  **BLOCKED，即阻塞状态，进入此状态，有以下几种情况**。
    
    1.  同步阻塞：锁被其他线程占用。
    2.  主动阻塞：调用 Thread 类的某些方法，主动让出 CPU 执行权，比如 sleep()、join() 等。
    3.  等到阻塞：执行了 wait()。
 *  **DEAD，即终止状态，是 run() 执行结束，或因异常退出后的状态，此状态不可逆转**。

保证高并发场景下的线程安全，可以从以下四个维度考量：

1.  **数据单线程内可见**。单线程总是安全的。通过限制数据仅在单线程内可见，可以避免数据被其他线程篡改。如，线程局部变量。
2.  **只读对象**。只读对象总是安全的。它的特性是允许复制、拒绝写入。如，String、Integer。
3.  **线程安全类**。某些线程安全类的内部有非常明确的线程安全机制。如，StringBuffer。
4.  **同步与锁机制**。如果想要对某个对象进行并发更新操作，但又不属于上述三类，需要开发工程师在代码中实现安全的同步机制。

线程安全的核心理念就是“要么只读，要么加锁”。JUC 并发包主要分成以下几个类族：

1.  **线程同步类**。这些类使线程间的协调更加容易，支持了更加丰富的线程协调场景。如，CountDownLatch、Semaphore、CyclicBarrier。
2.  **并发集合类**。集合并发操作的要求是执行速度快，提取数据准。如，ConcurrentHashMap、BlockingQueue、CopyOnWriteArrayList、ConcurrentSkipListMap。
3.  **线程管理类**。即线程池。
4.  **锁相关类**。锁以 Lock 接口为核心，派生出一些实际场景中进行互斥操作的锁相关类。如，ReentrantLock。

# 2. 锁 #

计算机的锁也是从开始的悲观锁，发展到后来的乐观锁、偏向锁、分段锁等。锁主要提供了两种特性：互斥性和不可见性。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 1]

## 并发包中的锁类 ##

在 AQS 中，定义了一个 ***volatile int state*** 变量作为共享资源，如果线程获取资源失败，则进入同步 FIFO 队列中等待；如果成功获取资源就执行临界区代码。执行完释放资源时，会通知同步队列中的等待线程来获取资源后出队并执行。

AQS 是抽象类，内置自旋锁实现的同步队列，封装入队和出队的操作，提供独占、共享、中断等特性的方法。

## 利用同步代码块 ##

**synchronized 锁**特性由 JVM 负责实现。JVM 底层通过监视锁来实现 **synchronized** 同步的。监视锁即 **monitor**，是每个对象与生俱来的一个隐藏字段。使用 **synchronized** 时，JVM 会根据 **synchronized** 的当前使用环境，找到对应对象的 **monitor**，再根据 **monitor** 的状态进行加、解锁的判断。

方法元信息中会使用 **ACC\_SYNCHRONIZED** 标识该方法是一个同步方法。同步代码块中会使用 **monitorenter** 即 **monitorexit** 两个字节码指令获取和释放 **monitor**。如果使用 **monitorenter** 进入时 **monitor** 为 0，表示该线程可以持有 **monitor** 后续代码，并将 **monitor** 加 1；如果当前线程已经持有了 **monitor**，那么 **monitor** 继续加 1；如果 **monitor** 非 0，其他线程就会进入阻塞状态。JVM 对 **synchronized** 的优化主要在于对 **monitor** 的加锁、解锁上。JDK6 后不断优化使得 **synchronized** 提供三种锁的实现，包括偏向锁、轻量级锁、重量级锁，还提供自动的升级和降级机制。**JVM 就是利用 CAS 在对象头上设置线程 ID，表示这个对象偏向于当前线程，这就是偏向锁**。

偏向锁是为了在资源没有被多线程竞争的情况下尽量减少锁带来的性能开销。在锁对象的对象头中有一个 ThreadId 字段，当第一个线程访问锁时，如果该锁没有被其他线程访问过，即 ThreadId 字段为空，那么 JVM 让其持有偏向锁，并将 ThreadId 字段的值设置为该线程的 ID。当下一次获取锁时，会判断当前线程的 ID 是否与锁对象的 ThreadId 一致。如果一致，那么该线程不会再重复获取锁，从而提高了程序的运行效率。如果出现锁的竞争情况，那么偏向锁会被撤销并升级为轻量级锁。如果资源的竞争非常激烈，会升级为重量级锁。**偏向锁可以降低无竞争开销，它不是互斥锁，不存在线程竞争的情况，省去再次同步判断的步骤，提升了性能**。

# 3. 线程同步 #

资源共享的两个原因是资源紧缺和共建需求。线程共享 CPU 是从资源紧缺的维度来考虑的，而多线程共享同一变量，通常是从共建需求的维度来考虑的。

所谓原子性是指不可分割的一系列操作指令，在执行完毕前不会被任何其他操作中断，要么全部执行，要么全部不执行。

## volatile ##

把 ***happen before*** 定位为方法 hb(a, b)，表示 a happen before b。如果 hb(a, b) 且 hb(b, c)，能够推导出 hb(a, c)。***happen before*** 是时钟顺序的先后，并不能保证线程交互的可见性。

可见性是指某线程修改共享变量的指令对其他线程来说都是可见的，它反映的是指令执行的实时透明度。

每个线程都有独占的内存区域，如操作栈、本地变量表等。线程本地内存保存了引用变量在堆内存中的副本，线程对变量的所有操作都在本地内存区域中进行，执行结束后再同步到堆内存中去。这里必然有一个时间差，在这个时间差内，该线程对副本的操作，对于其他线程都是不可见的。

当使用 **volatile** 修饰变量时，意味着任何对此变量的操作都会在内存中进行，不会产生副本，以保证共享变量的可见性，局部阻止了指令重排的发生。

锁也可以确保变量的可见性，但是实现方式和 **volatile** 略有不同。线程在得到锁时读入副本，释放时写回内存，锁的操作尤其要符合 happen before 原则。

**volatile** 只是轻量级的线程操作的可见方式，并非同步方式，如果是多写场景，一定会产生线程安全问题。如果是一写多读的并非场景，使用 **volatile** 修饰变量则非常合适。

## 信号量同步 ##

信号量同步是指在不同的线程之间，通过传递同步信号量来协调线程执行的先后次序。如果 **Semaphore** 的窗口信号量等于 1，就是最典型的互斥锁。

# 4. 线程池 #

线程池的作用：

1.  利用线程池管理并复用线程、控制最大并发数等。
2.  实现任务线程队列缓存策略和拒绝机制。
3.  实现某些与时间相关的功能，如定时执行、周期执行等。
4.  隔离线程环境。

***ThreadPoolExecutor*** 的构造方法如下：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

*  **corePoolSize**，表示常驻核心线程数。如果等于 0，则任务执行完之后，没有任何请求进入时销毁线程池的线程；如果大于 0，即使本地任何执行完毕，核心线程也不会被销毁。这个值的设置非常关键，设置过大会浪费资源，设置过小会导致线程频繁地创建或销毁。
 *  **maximumPoolSize**，表示线程池能够容纳同时执行的最大线程数。从构造函数来看，必须大于或等于 1。如果待执行的线程数大于此值，需要借助参数 **workQueue**，缓存在队列中，如果 **maximumPoolSize** 与 **corePoolSize** 相等，即是固定大小的线程池。
 *  **keepAliveTime**，表示线程池中的线程空闲时间，当空闲时间达到 **keepAliveTime** 值时，线程会被销毁，直到只剩下 **corePoolSize** 个线程为止，避免浪费内存和句柄资源。在默认情况下，当线程池的线程数大于 **corePoolSize** 时，**keepAliveTime** 才会起作用。但是当 ThreadPoolExecutor 的 allowCoreThreadTimeOut 变量设置为 true 时，核心线程超时后也会被回收。
 *  **TimeUnit**，表示时间单位。**keepAliveTime** 的时间单位通常是 TimeUnit.SECONDS。
 *  **workQueue**，表示缓存队列。当请求的线程数大于 **maximumPoolSize** 时，线程进入 BlockingQueue 阻塞队列。
 *  **threadFactory**，表示线程工厂。它用来生产一组相同任务的线程。线程池的命名是通过给这个 factory 增加组名前缀来实现的。在虚拟机栈分析时，就可以知道线程任务是由哪个线程工厂生产的。
 *  **handler**，表示执行拒绝策略的对象。当超过 **workQueue** 的任务缓存区上限的时候，就可以通过该策略处理请求，这是一种简单的限流保护。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 2]

***Executors*** 核心的方法有 5 个：

*  **Executors.newWorkStealingPool**：JDK8 引入，创建持有足够线程的线程池支持给定的并行度，并通过使用多个队列减少竞争，此构造方法中把 CPU 数量设置为默认的并行度。
 *  **Executors.newCachedThreadPool**：maximumPoolSize 最大可以至 Integer.MAX\_VALUE，是高度可伸缩的线程池。keepAliveTime 默认是 60 秒，工作线程处于空闲状态，则回收工作线程。如果任务数增加，再次创建出新线程处理任务。
 *  **Executors.newScheduledThreadPool**：线程数量最大至 Integer.MAX\_VALUE。它是 ScheduledExecutorService 接口家族的实现类，支持定时及周期性任务执行。相比 Timer，ScheduledExecutorService 更安全，功能更强大，与 newCachedThreadPool 的区别是不回收工作线程。
 *  **Executors.newSingleThreadExecutor**：创建一个单线程的线程池，相当于单线程串行执行所有任务，保证按任务的提交顺序依次执行。
 *  **Executors.newFixedThreadPool**：输入的参数既是固定线程数，又是核心线程数也是最大线程数，不存在空闲线程，所有 keepAliveTime 等于 0。

在 ThreadPoolExecutor 中提供了四个公开的内部静态类：

*  **AbortPolicy（默认）**：丢弃任务并抛出 RejectExecutionException 异常。
 *  **DiscardPolicy**：丢弃任务，但是不抛出异常，这是不推荐的做法。
 *  **DiscardOldestPolicy**：抛弃队列中等待最久的任务，然后把当前任务加入队列中。
 *  **CallerRunsPolicy**：调用任务的 run() 方法绕过线程池直接执行。

# 5. ThreadLocal #

## 引用类型 ##

**强引用（Strong Reference）**，只要对象有强引用指向，并且 GC Roots 可达，那么 Java 内存回收时，即使濒临内存耗尽，也不会回收该对象。

**软引用（Soft Reference）**，引用力度弱于强引用，是用在非必需对象的场景。在即将 OOM 之前，垃圾回收器会把这些软引用指向的对象加入回收范围，以获得更多的内存空间，让程序能够继续健康运行。**主要用来缓存服务器中间计算结果及不需要实时保存的用户行为等**。软引用一般用于在同一服务器内缓存中间结果。如果命中缓存，则提取缓存结果，否则重新计算或获取。

**弱引用（Weak Reference）**，引用强度较前两者更弱，也是用来描述非必需对象的。如果弱引用指向的对象只存在弱引用这一条线路，则在下一次 YGC 时会被回收。由于 YGC 时间的不确定性，弱引用何时被回收也具有不确定性。**弱引用主要用于指向某个易消失的对象，在强引用断开后，此引用不会劫持对象**。调用 ***WeakReference.get()*** 可能返回 null，要注意空指针异常。**WeakHashMap** 适用于缓存不敏感的临时信息的场景。

**虚引用（Phantom Reference）**，是极弱的一种引用关系，定义完成后，就无法通过该引用获取指向的对象。**为一个对象设置虚引用的唯一目的就是希望能在这个对象被回收时收到一个系统通知。虚引用必须与引用队列联合使用，当垃圾回收时，如果发现存在虚引用，就会在回收对象内存前，把这个虚引用加入与之关联的引用队列中**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 3]

## ThreadLocal 价值 ##

ThreadLocal 是每一个线程单独持有的。因为每一个线程都有独立的变量副本，其他线程不能访问，所以不存在线程安全问题，也不会影响程序的执行性能。ThreadLocal 对象通常是 private static 修饰的，因为都需要复制进入本地线程，所以非 static 作用不大。需要注意的是，ThreadLocal 无法解决共享对象的更新问题。

线程使用 ThreadLocal 有三个重要的方法：

1.  ***set()*** ：如果没有 **set()** 操作的 ThreadLocal，容易引起脏数据问题。
2.  ***get()*** ：始终没有 **get()** 操作的 ThreadLocal 对象是没有意义的。
3.  ***remove()*** ：如果没有 **remove()** 操作，容易引起内存泄漏。

ThreadLocal 通常用于同一个线程内，跨类、跨方法传递数据。如果没有 ThreadLocal，那么相互之间的信息传递，势必要靠返回值和参数，这样无形之中，有些类甚至有些框架会相互耦合。通过将 Thread 构造方法的最后一个参数设置为 true，可以把当前线程的变量继续往下传递给它创建的子线程。

使用 ThreadLocal 和 InheritableThreadLocal 透传上下文时，需要注意线程间切换、异常传输时的处理，避免在传输过程中因处理不当而导致的上下文丢失。

## ThreadLocal 副作用 ##

ThreadLocal 的主要问题是会产生脏数据和内存泄漏。这两个问题通常是在线程池的线程中使用 ThreadLocal 引发的，因为线程池有线程复用和内存常驻两个特点。

### 脏数据 ###

线程复用会产生脏数据。由于线程池会重用 Thread 对象，那么与 Thread 绑定的类的静态属性 ThreadLocal 变量也会被重用。如果在实现的线程 run() 方法体中不显示地调用 remove() 清理与线程相关的 ThreadLocal 信息，那么倘若下一个线程不调用 set() 设置初始值，就可能 get() 到重用的线程信息，包括 ThreadLocal 所关联的线程对象的 value 值。

### 内存泄漏 ###

在源码注释中提示使用 static 关键字来修饰 ThreadLocal。在此场景下，寄希望于 ThreadLocal 对象失去引用后，触发弱引用机制来回收 Entry 的 Value 就不现实了。

以上两个问题的解决方法很简单，就是在每次用完 ThreadLocal 时，必须要及时调用 remove() 方法清理。

**参考文献**

*  码出高效
 *  JCIP

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70]: /images/20220401/11be9d0e4d634420a6dac2f8684dc40f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 1]: /images/20220401/dac6b596d5fe40db9c95008e43b9b6ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 2]: /images/20220401/7b0ba309ac3c415f9e9319be979a30ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAzNzY3ODg_size_16_color_FFFFFF_t_70 3]: /images/20220401/107b1b1ff8164316b161d4c482c60d1c.png