Java并发和多线程编程学习(一) 并发初探和底层原理

本文的内容仅仅为个人结合书上学习的一些拙见，当然大部分都是绝对正确的，但有些地方没有书上那么深入，如偶有错误请大家不吝批评

1. 引言

• 并发编程的目的是为了让程序运行的更快，因为并发会启动很多的线程，而如果我们使用进程来处理这些问题，它的速度会很慢，因为线程较进程更为轻量级，进程切换时需要刷新$TLB($快表$)$并获取新的地址空间，然后切换硬件上下文和内核栈，而线程切换只需要切换硬件上下文和内核栈，这里的上下文切换可以理解为看书，如果你现在想去查一下字典，那么你必须先记住现在看到多少页了，也就是保存上一个任务的状态，任务从保存到再加载的过程就是一次上下文切换
• 但是在进行并发编程的时候，会遇到很多挑战，比如上下文切换、死锁、资源限制等问题，资源限制就是指并发编程的时候程序的执行速度受限于计算机硬件资源或者软件资源，例如服务器带宽只有2Mb/s，某个资源下载速度是1Mb/s，不会因为启动了10个线程下载就使得下载速度变成了10Mb/s，所以并发应用场景应该是并行的操作，或者说异步操作，使用并发比较合理，如果后面的程序依赖于前面的程序运行的结果，这样串行的效率反倒比并发更好

1.1 死锁

• 下面是一个死锁程序

/**
 * @Author: ComingLiu
 * @Date: 2022/10/4 20:24
 */
public class DeadLockDemo {
    private static final String A = "A";
    private static final String B = "B";

    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }
    private void deadLock(){
        Thread t1 = new Thread(() -> {
            synchronized (A){
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                synchronized (B){
                    System.out.println("1");
                }
            }
        });
        Thread t2 = new Thread(() ->{
            synchronized (B){
                synchronized (A){
                    System.out.println("2");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

• 这个程序的死锁思路就是首先在线程t1中$A$持锁，然后休眠1秒，这时候线程t2中$B$持锁，现在t2要拿$A$的锁，t1要拿$B$的锁，所以就陷入了死锁状态

2. Java并发机制的两个重要修饰符

2.1 volatile

• $volatile$是轻量级的$synchronized$，它在多处理器开发中保证了共享变量的“可见性”，意思就是如果有一个线程修改一个共享变量时，另外一个线程能读到这个修改的值，且$volatile$变量修饰符不会引起线程上下文的切换和调度，所以它的使用和执行成本更低
• $volatile$ 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值(一行汇编代码lock addl...，首先将当前处理器缓存行的数据写回到系统内存，这个写回内存的操作会使其他CPU里缓存了该内存地址的数据无效，这主要是应用了处理器的嗅探技术保证内部缓存、系统缓存和其他处理器的缓存的数据在总线上保持一致)。

2.2 synchronized

• $synchronized$修饰符修饰的方法同一时间只能被一个线程访问
• 它是存在于Java对象头里面的

那么synchronized锁的是什么呢？

1. 对于普通同步方法，锁是当前实例对象
2. 对于静态同步方法，锁是当前类的Class对象
3. 对于同步方法块，锁是Synchronized括号里配置的对象

3. Java中的锁

• 在Java SE1.6中，锁一共有4种状态，级别从低到高分别为无锁、偏向锁、轻量级锁、重量级锁，这几种状态会随着竞争情况逐渐升级，锁可以升级但是不能降级

3.1 偏向锁

• HotSpot的作者经过研究发现，大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需要简单测试一下对象头里面的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁；如果失败，需要再测试一下Mark Word(这是Java对象头里面的概念)中偏向锁的标识是否设置成1，这表示当前是偏向锁，如果没有设置就用CAS竞争锁，否则尝试使用CAS将对象头的偏向锁指向当前线程
• 撤销偏向锁的时候是等到其他线程尝试竞争，才释放

3.2 轻量级锁

• 加锁：线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，然后线程使用CAS尝试将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程尝试使用自旋来获取锁
• 解锁：使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生；如果失败说明当前锁存在竞争，锁就会膨胀成重量级锁

3.3 重量级锁

• synchronized是通过对象底部的一个叫做监视器锁(monitor)来实现的，监视器锁本身依赖底层操作系统的Mutex Lock来实现，因为操作系统实现线程的切换需要从用户态切换到核心态，成本非常高，所以称为重量级锁

4. 原子操作及其实现原理

• 原子操作就是不可被中断的一个或者一系列操作
• CAS就是比较并交换(Compare and Swap)，意思就是拿一个旧值和一个新值，操作期间比较旧值有没有发生变化，如果没变化才交换成新值（可能有人会问万一比较之后又被修改了怎么办？事实上比较并交换这整个过程都是原子的）
• CPU流水线指的是在CPU中由5-6个不同功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5-6步后再有这些电路单元分别执行，这样就能实现在一个CPU时钟周期完成一条指令，因此提高了CPU的运算速度

4.1 处理器如何实现原子操作

32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作

1. 总线锁：就是处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器就可以独占共享内存
2. 缓存锁：总线锁会锁定CPU和内存之间的通信，效率较低，缓存锁使用缓存一致性机制来保证操作的原子性，也就是如果一个处理器回写已被锁定的缓存行（缓存的最小操作单位）的数据时，会使缓存行无效

4.2 Java如何实现原子操作

• 通过锁和循环CAS的方式来实现原子操作，此外从Java1.5开始，JDK的并发包里面提供了一些类来支持原子操作，比如AtomicBoolean，AtomicInteger，AtomicLong
• CAS的ABA问题：就是一个线程改完之后还是原来那个，然后后来的线程发现这个值没变，实际上变了，那么解决办法就是前面加一个版本号，也就是ABA变成了1A->2B->3A，同时JDK的Atomic包里面提供了一个类AtomicStampedRefrence来解决这个问题

参考

• 2022年7月第1版，方腾飞，魏鹏，程晓明《Java并发编程的艺术》
• https://www.runoob.com/java
• https://zhuanlan.zhihu.com/p/420560153