JUC-java并发编程的艺术

HBryce24

已于 2024-04-12 14:16:31 修改

阅读量911

点赞数 26

分类专栏：并发文章标签： java

于 2024-02-06 14:24:12 首次发布

本文链接：https://blog.csdn.net/HBryce24/article/details/136044067

版权

并发专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、并发问题

上下文切换：CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。
1. 多线程不一定快：多线程有线程创建和上下文切换的开销。
2. 减少上下文切换：
  1. 无锁并发：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据
  2. CAS算法
  3. 使用最少线程：避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态
  4. 使用协程：在单线程里实现多任务调度，并在单线程里维持多个任务间的切换

死锁：线程A持有资源，线程B持有资源；他们都想申请对方的资源，这两个线程就会相互等待而进入死锁状态。（互相等待对方释放锁）

代码：

public class Test {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        new Thread(() ->{
            synchronized (o1) {
                try {
                    System.out.println("get o1");
                    Thread.sleep(1000);
                } catch (Exception ignored){}
                synchronized (o2) {
                    System.out.println("get o2");
                }
            }
        }).start();

        new Thread(() ->{
            synchronized (o2) {
                try {
                    System.out.println("get o2");
                    Thread.sleep(1000);
                } catch (Exception ignored){}
                synchronized (o1) {
                    System.out.println("get o1");
                }
            }
        }).start();
    }
}

避免死锁的办法

避免一个线程同时获取多个锁
避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
尝试使用定时锁，使用 lock.tryLock （ timeout ）来替代使用内部锁机制
对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败

资源限制
1. 程序的执行速度受限于计算机硬件或者是软件资源。
2. 问题：导致并发执行变为串行执行，开启并发线程速度可能会很慢。因为上下文切换占用了大量的时间。

二、java并发底层实现

Java 代码在编译后会变成 Java 字节码，字节码被类加载器加载到 JVM 里， JVM 执行字节码，最终需要转化为汇编指令在 CPU 上执行， Java 中所使用的并发机制依赖于 JVM 的实现和CPU 的指令。

2.1、volatile

volatile是轻量级的synchronized，保证多处理器开发的共享变量的可见性。
可见性的意思是一个线程修改共享变量的时候，其它线程可以读到这个值。
volatile的成本比synchronized成本更低，不会引起线程的上下文切换和调度。

1、volatile的定义与实现原理

如果一个字段被声明为volatile，那么java线程的内存模型确保所有线程看到这个变量的值是一致的。
volatile相关的CPU术语介绍，在下面。

2、volatile如何保证可见性

当一个线程修改了一个volatile变量的值，会将这个值刷新到主内存中，并且会使用某种机制通知其他线程该变量发生变化。其他线程需要读取这个变量时，则会去主内存中读取最新的值。
具体机制：volatile共享变量进行写操作的时候多出lock前缀的汇编
- lock前缀的指令在多核处理器引发的事件
  - 把当前的处理器缓存行的数据写到系统的内存
  - 这个写回内存的操作会使其它CPU里面缓存的该地址的数据无效。
- 即使写回了内存，其它的处理器缓存的数据其实还是旧的。
  - 每个处理器通过嗅探总线传播的数据，检查自己的缓存是不是过期了。
  - 如果发现过期了那么就把缓存行设置为无效的状态。并且重新去内存读取数据。
小结：volatile的底层原理其实就是通过lock信号和MESI协议通知所有的处理器缓存失效，并且把数据更新到了内存。

2.2、Synchronized

Java SE1.6对synchronized进行优化，引入偏向锁和轻量级锁，以及锁存储结构和升级过程。
synchronized实现同步的基础
- 普通方法锁的是当前实例对象
- 静态同步方法锁的是当前类Class对象
- 同步方法块，锁住的是synchronized括号里面的对象
线程访问同步代码的时候必须要得到锁，退出或抛出异常时必须释放锁
锁到底存在哪里呢？锁里面会存储什么信息呢？
- 同步方法块使用的是monitorenter和monitorexit，monitorenter指令指向同步代码块开始的位置，monitorexit指向同步代码块结束的位置；线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁
- 同步方法：使用ACC_SYNCHRONIZED标识，指明该方法是一个同步方法
- 本质是对一个对象的监视器（ monitor ）进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由 synchronized 所保护对象的监视器
- monitor对象存在每个java对象的对象头中

2.2.1对象头

synchronized 用的锁存在 Java 对象头里。如果对象是数组类型，则虚拟机用12个字节存储对象头，如果对象是非数组类型，则用 8个字节存储对象头
Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位
在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。

2.2.2锁升级

锁状态：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，目的是为了提高获得锁和释放锁的效率

偏向锁
- 若不存在多线程竞争，经常由某个线程获取。为了让次线程获取锁的代价更低，引入了偏向锁
- 线程访问获取锁的时候，会在对象头和栈帧的锁记录存储锁偏向的线程ID，那么该线程获取锁的时候就不需要去CAS来加锁和解锁。只需要检测Mark Word里面的线程ID是否指向当前线程
- 偏向锁的撤销
  - 偏向锁是等待要竞争的时候才会释放锁的机制。
  - 如果有其他线程竞争锁，那么首先是暂停持有锁的线程，并且检查是不是存活，如果是拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向其他线程。要么就是恢复到无锁，或者标记对象不适合作为偏向锁。最后唤醒暂停的线程。
  - 如果持有的线程结束，那么就标记为无锁的状态。
  - 另一个线程如果CAS失败那么就会暂停持有的线程，持有的线程会解锁，并且把锁的线程ID设置为空。然后恢复线程。
轻量级锁
- 轻量级加锁
  - 线程执行同步块之前，JVM会在线程里面创建锁记录的空间，并且把对象头的Mark Word复制到锁记录中。
  - 然后通过CAS来把Mark Word替换为指向锁记录的指针。
  - 如果成功那么就获取到轻量级的锁。
  - 如果失败说明有其他线程竞争，那么线程就尝试自旋获取锁。
- 轻量级解锁
  - 通过CAS把Mark Word恢复到对象头。
  - 如果成功，那么说明没有竞争，失败说明有竞争。这个时候释放锁，并且唤醒等待的线程。因为已经锁膨胀所以Mark Word指向的是重量级锁的
  - 如果失败那么就会膨胀为重量级的锁。这个时候竞争的线程2会把锁改为10也就是重量级锁。
锁的优缺点

2.3、java中实现原子操作

使用循环CAS实现原子操作：实际上就是检查和赋值合成一个原子操作。通过CMPXCHG指令完成自旋。
- CAS实现原子操作的三大问题
  - ABA问题
  - 循环时间长开销大。如果CAS不成功，就会一直自旋。可
  - 只能保证一个共享变量的原子操作，对于多个变量它是无法处理的。
使用锁机制实现原子操作：保证了只有获取锁的线程才能够操作锁定的内存区域。

三、java内存模型

3.1、JMM基础

3.2、重排序

3.2.1、数据依赖性

如果两个操作对一个共享变量操作，而且有一个是写操作，那么两个操作就是数据依赖的。
编译器和处理器都是遵循数据依赖性的（单个处理器中）

3.2.2、as-if-serial

as-if-serial语义就是不管怎么重排序，执行结果都是不会变的。
所以编译器和处理器不会对数据依赖的指令进行重排序

3.2.3、程序顺序规则

只要指令之间有可见性的关系，那么就不能够重排序。如果前一个操作不需要对后面的操作可见，那么就可以重排序

3.2.4、重排序对多线程的影响

重排序可能会把多线程执行的结果修改。

3.3、顺序一致性

3.4、volatile的内存语义

插入内存屏障保证禁止指令重排

3.5、锁的内存语义

3.5.1、锁的释放-获取建立的happens-before关系

3.5.2、锁的释放和获取的内存语义

线程释放锁的时候，JMM会把该线程对应的本地内存共享变量刷新到主内存
线程获取锁的时候,JMM会把线程的本地内存设置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量
可以看到锁释放的内存语义和volatile写的是一样的。获取锁语义和volatile读是一样的
- 线程A释放锁，实质是线程A对某个要获取锁的线程发出要对共享变量修改的消息
- 线程B获取锁，实质是线程B接收了某个线程发出的修改消息
- 线程A释放锁和线程B获取锁，实质上是线程A通过主内存向线程B发送消息

3.6、final域的内存语义

3.7、happens-before

3.7.1、happens-before的定义

如果线程A的写操作a和线程B的读操作b存在happens-before，那么JMM可以保证a一定是对于b是可见的。
JSR-133的定义
- 如果一个操作happens-before另一个操作，第一个操作对第二个操作的可见，并且第一个操作在第二个操作之前
- 两个操作存在happens-before关系，并不意味着Java平台具体实现要按照这个顺序执行。如果重排序之后结果一致，那么这种重排序是可以的。
JMM的承诺
- JMM对程序员承诺A happens-before B，也就是A的结果对B是可见的。A的执行顺序在B之前。
- JMM对编译器和处理器的承诺，只要不改变结果就可以优化。
as-if-serial语义保证单线程内执行结果不被改变，happens-before关系保证同步的多线程执行结果不会改变。
as-if-serial语义给程序员创建了幻境，单线程程序按照程序顺序执行，happens-before的幻境就是正确的同步多线程是按照happens-before指定的顺序执行的。

3.7.2、happens-before规则

程序顺序规则
监视器锁规则
volatile变量规则
传递性
start()规则
join()规则

3.8、DCL和延迟初始化

public class Singleton {
    private volatile static Singleton uniqueInstance;
    private Singleton(){}
    public static Singleton getUniqueInstance(){
        //判断对象是否实例过
        if (uniqueInstance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

uniqueInstance = new Singleton();分三步

为uniqueInstance分配内存空间
初始化uniqueInstance
将uniqueInstance指向分配好的内存地址；

JVM具有指令重排，指向顺序可能变成1->3->2。如，线程T1执行了1和3，T2调用方法发现uniqueInstance不为null直接返回，然而uniqueInstance还没被初始化。volatile可以禁止指令重排

3.9、JMM综述

四、多线程

4.1、线程简介

4.1.1、什么是线程

现代操作系统在运行一个程序时，会为其创建一个进程。现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process ），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行（并发）。

4.1.2、为什么使用多线程

更多的处理器核心，以及超线程技术的广泛运用
更快的响应时间

4.1.3、线程优先级

现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。
Java中，可以使用Thread类的setPriority()方法来设置线程的优先级。线程的优先级介于1到10，其中10是最高优先级，1是最低优先级。默认情况下，线程的优先级为5。
注：线程优先级是提示给操作系统的，操作系统可能会根据自己的调度策略来决定线程的实际执行顺序。因此，即使设置了线程的优先级，也不能保证线程一定会按照优先级顺序执行。

4.1.4、线程状态

NEW：初始转态，线程被构建，但还没有调用start()方法
RUNNABLE：运行状态
BLOCKED：阻塞状态，表示线程阻塞于锁
WAITING：等待状态，进入该状态表示当前线程需要等待其他线程通知或中断
TIME_WAITING：超时等待，在指定的时间自行返回
TERMINATED：终止状态，表示当前线程已经执行完毕
线程创建之后，调用start()方法开始运行。当线程执行wait()方法之后，线程进入等待状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而超时等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到阻塞状态。线程在执行Runnable的run()方法之后将会进入到终止状态。

4.1.5、Daemon线程

Daemon线程是一种支持型线程(守护线程)，主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中所有用户线程结束时，Java虚拟机将会退出，所有Daemon线程都需要立即终止。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

Daemon 属性需要在启动线程之前设置，不能在启动线程之后设置。
在Java虚拟机退出时Daemon线程中的finally块并不一定会执行

4.2、启动和终止线程

4.2.1、构造线程

在运行线程之前首先要构造一个线程对象，线程对象在构造的时候需要提供线程所需要的属性，如线程所属的线程组、线程优先级、是否是Daemon线程等信息。

Thread中对线程进行初始化

    private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
        //当前线程就是该线程的父线程
        Thread parent = currentThread();
        this.group = g;
         将daemon、priority属性设置为父线程的对应属性
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        this.target = target;
        setPriority(priority);
        // 将父线程的InheritableThreadLocal复制过来
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Set thread ID */
        this.tid = nextThreadID();
    }

在上述过程中，一个新构造的线程对象是由其 parent 线程来进行空间分配的，而 child 线程继承了 parent 是否为 Daemon 、优先级和加载资源的 contextClassLoader 以及可继承的 ThreadLocal ，同时还会分配一个唯一的 ID 来标识这个 child 线程。至此，一个能够运行的线程对象就初始化好了，在堆内存中等待着运行

4.2.2、启动线程

线程在初始化完成之后，调用 start() 方法就可以启动该线程。s tart() 方法的含义是：当前线程（即 parent 线程）同步告知 Java 虚拟机，只要线程规划器空闲，应立即启动调用start() 方法的线程。

4.2.3、中断

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()方法对其进行中断操作。

4.2.4、过期的suspend()、resume()、和stop()

suspend() 、 resume() 和 stop() 方法完成了线程的暂停、恢复和终止工作
不建议使用的原因主要有： suspend() 方法在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样， stop() 方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态

4.3、线程间通信

4.3.1、volatile和synchronized关键字

volatile可以用来修饰字段（成员变量），告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。过多地使用volatile是不必要的，因为它会降低程序执行的效率。
synchronized 可以修饰方法或者以同步块的形式来进行使用，确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，保证了线程对变量访问的可见性和排他性。
- 对象、对象的监视器、同步队列和执行线程之间的关系
- 任意线程对 Object （ synchronized 保护）的访问，首先要获得Object 的监视器。如果获取失败，线程进入同步队列，线程状态变为 BLOCKED 。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

4.3.2、等待/通知机制

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了 “ 做什么 ” （ what ）和 “ 怎么做 ” （ How ），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性。

等待 / 通知的相关方法是任意 Java 对象都具备的，因为这些方法被定义在所有对象的父类java.lang.Object 上
等待 / 通知机制，是指一个线程 A 调用了对象 O 的 wait() 方法进入等待状态，而另一个线程B调用了对象 O 的 notify() 或者 notifyAll() 方法，线程 A 收到通知后从对象 O 的 wait() 方法返回，进而执行后续操作。上述两个线程通过对象 O 来完成交互，而对象上的 wait() 和 notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

使用 wait() 、 notify() 和 notifyAll() 时需要先对调用对象加锁。
调用 wait() 方法后，线程状态由 RUNNING 变 WAITING ，并将当前线程放置到对象的等待队列。
notify() 或 notifyAll() 方法调用后，等待线程依旧不会从 wait() 返回，需要调用 notify()或 notifAll() 的线程释放锁之后，等待线程才有机会从 wait() 返回。
notify() 方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING变为 BLOCKED。
从 wait() 方法返回的前提是获得了调用对象的锁。
从上述细节中可以看到，等待 / 通知机制依托于同步机制，其目的就是确保等待线程从wait() 方法返回时能够感知到通知线程对变量做出的修改。

过程：WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行

4.3.3、等待/通知的今典范式

等待方
- 获取对象的锁
- 如果条件不满足，那么调用对象的 wait() 方法，被通知后仍要检查条件
- 条件满足则执行对应的逻辑。
```
synchronized(对象) {
    while(条件不满足) {
        对象.wait();
    }
    对应的处理逻辑
}
```
通知方
- 获得对象的锁
- 改变条件
- 通知所有等待在对象上的线程
```
synchronized(对象) {
    改变条件
    对象.notifyAll();
}
```

4.3.4、Thread.join()

如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回
JDK 中 Thread.join() 方法的源码
```
public final synchronized void join(final long millis) throws InterruptedException {
    while (isAlive()) {
        wait(0);
    }
}
```
当线程终止时，会调用线程自身的 notifyAll() 方法，会通知所有等待在该线程对象上的线

程。可以看到 join() 方法的逻辑结构与等待 / 通知经典范式一致

4.3.5、ThreadLocal

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个程上的一个值。可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。

五、java中的锁

5.1、Lock接口

锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。在 Lock接口出现之前， Java 程序是靠 synchronized 关键字实现锁功能的，而 Java SE 5 之后，并发包中新增了L ock 接口（以及相关实现类）用来实现锁功能，它提供了与 synchronized 关键字类似的同步功

能，只是在使用时需要显式地获取和释放锁。虽然它缺少了（通过 synchronized 块或者方法所提供的）隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性、可中断的获取锁以及超时获取锁等多种 synchronized 关键字所不具备的同步特性

使用

Lock lock = new ReentrantLock();
lock.lock();
try {

} finally {
    //在finally块中释放锁，目的是保证在获取到锁之后，最终能够被释放
    lock.unlock();
}

Lock接口提供的synchronized关键字所不具备的特性
Lock是一个接口，它定义了锁获取和释放的基本操作

5.2、队列同步器-ASQ

队列同步器AbstractQueuedSynchronizer用来构建锁，或者其它同步组件。用一个int成员变量表示同步状态。通过内置的FIFO队列完成资源获取线程的排队工作。
同步器的实现主要是继承，同步器需要提供（getState()、setState(int newState)和compareAndSetState(int expect,int update)）方法来获取同步的状态。
同步器支持独占或者是共享地获取锁。
同步器是实现锁（同步组件）的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。可以这样理解二者之间的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁和同步器很好地隔离了使用者和实现者所需关注的领域。

5.2.1、AQS接口

同步器的设计是基于模板方法模式的，也就是说，使用者需要继承同步器并重写指定的方法，随后将同步器组合在自定义同步组件的实现中，并调用同步器提供的模板方法，而这些模板方法将会调用使用者重写的方法。
实现自定义同步组件时，将会调用同步器提供的模板方法

同步器提供的模板方法基本上分为 3 类：独占式获取与释放同步状态、共享式获取与释放

同步状态和查询同步队列中的等待线程情况

5.2.2、AQS的实现

同步队列：同步器依赖内部的同步队列（一个FIFO双向队列）来完成同步状态的管理，当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试获取同步状态
独占式同步状态获取与释放
共享式同步状态获取与释放：共享式获取与独占式获取最主要的区别在于同一时刻能否有多个线程同时获取到同步状态。
独占式超时获取同步状态：通过调用同步器的doAcquireNanos(int arg,long nanosTimeout)方法可以超时获取同步状态，即在指定的时间段内获取同步状态，如果获取到同步状态则返回true，否则，返回false

5.3、重入锁

重入锁 ReentrantLock ，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。

实现重进入：是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞
1. 线程再次获取锁：锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再
  次成功获取。
2. 锁的最终释放：线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到
  该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于 0 时表示锁已经成功释放。
公平与非公平获取锁
1. 公平锁：如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是FIFO。
2. 非公平锁：

5.4、读写锁

读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升；
一般情况下，读写锁的性能都会比排它锁好，因为大多数场景读是多于写的。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。 Java 并发包提供读写锁的实现是 ReentrantReadWriteLock

写锁的获取与释放：写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态。
读锁的获取与释放：读锁是一个支持重进入的共享锁，它能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功地获取，而所做的也只是（线程安全的）增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。
锁降级：锁降级指的是写锁降级成为读锁。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程

5.5、LockSupport

当需要阻塞或唤醒一个线程的时候，可使用 LockSupport 工具类来完成相应工作。 LockSupport 定义了一组的公共静态方法，这些方法提供了最基本的线程阻塞和唤醒功能，而 LockSupport 也成为构建同步组件的基础工具。LockSupport 定义了一组以 park 开头的方法用来阻塞当前线程，以及unpark(Thread thread) 方法来唤醒一个被阻塞的线程。

5.6、Condition

任意一个 Java 对象，都拥有一组监视器方法（定义在 java.lang.Object 上），主要包括 wait()、wait(long timeout) 、 notify() 以及 notifyAll() 方法，这些方法与 synchronized 同步关键字配合，可以实现等待 / 通知模式。 Condition 接口也提供了类似 Object 的监视器方法，与 Lock 配合可以实现等待/通知模式

5.6.1Condition接口

Condition 定义了等待 / 通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition 对象关联的锁。 Condition 对象是由 Lock 对象（调用 Lock 对象的 newCondition() 方法）创建出来的，换句话说， Condition 是依赖 Lock 对象的。

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void conditionWait() throws InterruptedException {
    lock.lock();
    try {
        condition.await();
    } finally {
        lock.unlock();
    }
}

public void conditionSignal() throws InterruptedException {
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
}

5.6.2、Condition的实现

ConditionObject 是同步器 AbstractQueuedSynchronizer 的内部类，因为 Condition的操作需要获取相关联的锁，所以作为同步器的内部类也较为合理。每个 Condition 对象都包含着一个队列（以下称为等待队列），该队列是 Condition 对象实现等待 / 通知功能的关键。下面将分析 Condition 的实现，主要包括：等待队列、等待和通知。

等待队列：等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。一个Condition包含一个等待队列，Condition拥有首节点（firstWaiter）和尾节点（lastWaiter）。当前线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列。
等待：调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了Condition相关联的锁。如果从队列（同步队列和等待队列）的角度看await()方法，当调用await()方法时，相当于同步队列的首节点（获取了锁的节点）移动到Condition的等待队列中
通知：调用Condition的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。

六、java并发容器和框架

6.1、ConcurrentHashMap的实现原理与使用

ConcurrentHashMap是线程安全且高效的HashMap

6.1.1、为什么使用ConcurrentHashMap

HashMap不安全
HashTable效率低（synchronized）
CurrentHashMap采用锁分段技术可有效提升并发访问率

6.1.2、ConcurrentHashMap的结构

6.1.3、ConcurrentHashMap初始化

6.1.4、定位Segment

6.1.5、ConcurrentHashMap的操作

6.2、ConcurrentLinkedQueue

在并发编程中，有时候需要使用线程安全的队列。如果要实现一个线程安全的队列有两种方式：一种是使用阻塞算法，另一种是使用非阻塞算法。使用阻塞算法的队列可以用一个锁（入队和出队用同一把锁）或两个锁（入队和出队用不同的锁）等方式来实现。非阻塞的实现方式则可以使用循环CAS的方式来实现。

ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列，它采用先进先出的规则对节点进行排序，当我们添加一个元素的时候，它会添加到队列的尾部；当我们获取一个元素时，它会返回队列头部的元素。

6.3、阻塞队列

当队列满时，队列会阻塞插入元素的线程，直到队列不满；在队列为空时，获取元素的线程会等待队列变为非空。
阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器
ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列
LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列
DelayQueue：一个使用优先级队列实现的无界阻塞队列
SynchronousQueue：一个不存储元素的阻塞队列，每一个put操作必须等待一个take操作，
否则不能继续添加元素
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

6.3.1、阻塞队列实现原理：

使用通知模式实现。所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生

产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。
- ArrayBlockingQueue使用了Condition来实现，当往队列里插入一个元素时，如果队列不可用，那么阻塞生产者主要通过LockSupport.park（this）来实现

6.4、Fork/Join框架

把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架

七、java中的原子类

原子更新基本类型、原子更新数组、原子更新引用和原子更新属性，Atomic 包里的类基本都是使用 Unsafe 实现的包装类。采用CAS

原子更新基本类型：AtomicBoolean、AtomicInteger、AtomicLong
- Unsafe只提供了3种CAS方法：compareAndSwapObject、compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现它是先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新char、float和double变量也可以用类似的思路来实现
原子更新数组：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
原子更新引用：AtomicReference
原子更新属性

八、java中的并发工具

8.1、CountDownLatch

允许一个或多个线程等待其他线程完成操作

使用：CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N。当我们调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变成零。由于countDown方法可以用在任何地方，所以这里说的N个点，可以是N个线程，也可以是1个线程里的N个执行步骤。用在多个线程时，只需要把这个 CountDownLatch的引用传递到线程里即可
如果有线程处理得比较慢，我们不可能让主线程一直等待，所以可以使用另外一个带指定时间的await方法——await（long time，TimeUnit unit），这个方法等待特定时间后，就会不再阻塞当前线程
数器必须大于等于 0 ，只是等于 0 时候，计数器就是零，调用 await 方法时不会阻塞当前线程。 CountDownLatch 不可能重新初始化或者修改 CountDownLatch 对象的内部计数器的值。一个线程调用 countDown 方法 happen-before 另外一个线程调用 await 方法。

8.2、CyclicBarrier

让一组线程到达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

使用：CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
场景：可以用于多线程计算数据，最后合并计算结果的场景
CyclicBarrier和CountDownLatch的区别：CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景

8.3、Semaphore

是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源

应用场景：流量控制

8.4、Exchanger

是一个用于线程间协作的工具类。 Exchanger 用于进行线程间的数据交换。它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据。这两个线程通过exchange 方法交换数据，如果第一个线程先执行 exchange() 方法，它会一直等待第二个线程也执行 exchange 方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方

应用场景：用于遗传算法

九、java中的线程池

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

9.1、线程池的实现原理

ThreadPoolExecutor执行：

如果当前运行的线程少于 corePoolSize ，则创建新线程来执行任务（注意，执行这一步骤

需要获取全局锁）。
如果运行的线程等于或多于 corePoolSize ，则将任务加入 BlockingQueue。
如果无法将任务加入 BlockingQueue （队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。
如果创建新线程将使当前运行的线程超出 maximumPoolSize ，任务将被拒绝，并调用

RejectedExecutionHandler.rejectedExecution()方法

ThreadPoolExecutor 采取上述步骤的总体设计思路，是为了在执行 execute() 方法时，尽可能地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在 ThreadPoolExecutor 完成预热之后（当前运行的线程数大于等于 corePoolSize ），几乎所有的 execute() 方法调用都是执行步骤 2，而步骤 2 不需要获取全局锁。

9.2、线程池的使用

ThreadPoolExecutor创建线程池

参数

corePoolSize （核心线程数）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的 prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。
BlockingQueue（阻塞队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。
- ArrayBlockingQueue ：是一个基于数组结构的有界阻塞队列，此队列按 FIFO （先进先出）原则对元素进行排序。
- LinkedBlockingQueue ：一个基于链表结构的阻塞队列，此队列按 FIFO排序元素，吞吐量通常要高于 ArrayBlockingQueue 。静态工厂方法 Executors.newFixedThreadPool() 使用了这个队列。
- SynchronousQueue ：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 Linked-BlockingQueue ，静态工厂方法 Executors.newCachedThreadPool 使用了这个队列。
- PriorityBlockingQueue ：一个具有优先级的无限阻塞队列。
maximumPoolSize （最大线程数）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。
ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
RejectedExecutionHandler （拒绝策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。
- AbortPolicy：直接抛出异常（默认）
  
  CallerRunsPolicy：让调用者所在线程来运行任务
  
  DiscardOldestPolicy：丢弃队列里最近的一个任务
  
  DiscardPolicy：不处理，丢弃掉
keepAliveTime（线程存活时间）：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。
TimeUnit （线程活动保持时间的单位）

提交任务

execute()：用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功
subimit()：用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线
程一段时间后立即返回，这时候有可能任务没有执行完

关闭线程池：

通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程

只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法

合理配置线程数

任务的性质：CPU密集型任务、IO密集型任务和混合型任务
任务的优先级：高、中和低
任务的执行时间：长、中和短
任务的依赖性：是否依赖其他系统资源，如数据库连接
质不同的任务可以用不同规模的线程池分开处理。 CPU 密集型任务应配置尽可能小的线程，如配置 N cpu +1 个线程的线程池。由于 IO 密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如 2*N cpu 。混合型的任务
依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU

线程池监控

如果在系统中大量使用线程池，则有必要对线程池进行监控，方便在出现问题时，可以根据线程池的使用状况快速定位问题。

t askCount ：线程池需要执行的任务数量。
completedTaskCount ：线程池在运行过程中已完成的任务数量，小于或等于 taskCount 。
largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。
getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。
getActiveCount：获取活动的线程数

十、Executor框架

在 Java 中，使用线程来异步执行任务。 Java 线程的创建与销毁需要一定的开销，如果我们为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。 Java 的线程既是工作单元，也是执行机制。从 JDK 5 开始，把工作单元与执行机制分离开来。工作单元包括 Runnable 和 Callable ，而执行机制由 Executor 框架提供。

10.1、Executor

在 HotSpot VM 的线程模型中， Java 线程（java.lang.Thread ）被一对一映射为本地操作系统线程。 Java 线程启动时会创建一个本地操作系统线程；当该 Java 线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的 CPU。在上层， Java 多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（ Executor 框架）将这些任务映射为固定数量的线程；在底层，操作系统内核将这些线程映射到硬件处理器上。

结构

任务。包括被执行任务需要实现的接口： Runnable 接口或 Callable接口。
任务的执行。包括任务执行机制的核心接口 Executor ，以及继承自 Executor的 ExecutorService 接口。 Executor 框架有两个关键类实现了 ExecutorService接口（ ThreadPoolExecutor 和 ScheduledThreadPoolExecutor）。
异步计算的结果。包括接口 Future 和实现 Future 接口的 FutureTask 类。

Executor 框架包含的主要的类与接口

Executor 是一个接口，它是 Executor 框架的基础，它将任务的提交与任务的执行分离开来。
ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执

行命令。 ScheduledThreadPoolExecutor 比 Timer 更灵活，功能更强大。
Future 接口和实现 Future 接口的 FutureTask 类，代表异步计算的结果。
Runnable 接口和 Callable 接口的实现类，都可以被 ThreadPoolExecutor 或Scheduled和ThreadPoolExecutor 执行。

Executor框架成员

ThreadPoolExecutor：ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的ThreadPoolExecutor
- SingleThreadExecutor：单个线程，corePoolSize和maximumPoolSize被设置为1，用无界队列
- FixedThreadPool：固定线程数，KeepAliveTime设置为0L，用无界队列
- CachedThreadPool：大小无界的线程池，corePoolSize被设置为0，maximumPoolSize被设置为Integer.MAX_VALUE
- ScheduledThreadPoolExecutor：要用来在给定的延迟之后运行任务，或者定期执行任务。DelayQueue无界队列
Future接口
Runnable接口：无返回结果
Callable接口：有返回结果
Executors