八股文-多线程、并发

八股文-多线程、并发

最近学到了一种方法，可以用于简历项目经验编写以及面试题目的回答

STAR法则：在什么背景下，你需要解决什么问题，你做了啥，得到了什么结果
情境（Situation）： 描述你面对的特定情境或背景。
任务（Task）： 说明你面临的具体任务或挑战。
行动（Action）： 阐述你采取了什么行动来解决问题或完成任务。
结果（Result）： 指出你的行动带来了什么结果，以及你取得了什么成就。
参考：https://blog.youkuaiyun.com/qq_37037348/article/details/139144523

多线程是啥？为啥要有多线程？

在单个程序中可以同时运行多个线程执行不同的任务。学习了一个操作系统上面运行多个进程的方法，一个进程上面用多个线程管理。计算机最早出现的时候还没有操作系统，程序直接运行在计算机上，这样一个计算机的功能有限，资源利用率也不高。所以就出现了操作系统，通过进程的方式实现一个计算机可以同时运行多个程序，同时一个程序里面又需要处理多种任务，如果所以任务用一个线程来执行，那么多个任务只能排队处理，同样效率低下，无法好好的利用资源（内存、磁盘IO、CPU等）。
并行处理、充分利用资源 → 提高性能和效率、改善用户体验

使用多线程带来的问题？

线程安全问题（一致性问题）、死锁（相互等待）、资源争抢（CPU时间、内存、I/O）、编程复杂、可见性（内存分为工作内存和主内存，这样做主要是为了提高效率）、有序性问题（指令重排）

怎么解决这些问题？

同步机制（volatile、synchronized、原子类、Lock显式锁）

指令重排是什么？为啥要指令重排？

编译器或者处理器对指令执行顺序进行调整，为了提高执行效率。对于重排的指令会遵循以下原则：不影响单线程执行的语义。但是多线程就不能够保证了（会出现可见性问题、有序性问题）。多线程下正常执行语句也不能够保证原子性，所以基于这两种场景，为了保证并发安全性，就出现了锁和其他的一些机制。主要包括volatile，synchronized，显式锁，原子类等

解决指令重排的方法：
Java提供了一些机制来解决指令重排带来的问题：

volatile关键字：通过使用volatile关键字，可以确保变量的读写操作对所有线程都是可见的，并且保证操作的有序性。volatile变量的写操作对任意后续的volatile变量的读操作都是可见的。（内存屏障阻止重排序，https://juejin.cn/post/6901283327160877063）

synchronized关键字：使用synchronized可以确保同一时间只有一个线程可以执行同步代码块，从而保证操作的原子性和有序性。

final关键字：对于final字段，一旦初始化完成，其值就不会被改变。这可以确保在构造函数中对final字段的赋值在构造函数结束后对其他线程是可见的。

原子类：Java提供了一系列的原子类（如AtomicInteger），这些类利用CAS（Compare-And-Swap）操作来保证操作的原子性，从而避免指令重排的问题。

指令重排为啥能够提高执行效率？

这个就是编译器和处理器做的一些优化，主要原则是提高各个硬件（CPU、内存、寄存器）的利用率，减少空闲时间

volatile是啥？有什么用？

这个就得说到JMM，Java内存模型（Java Memory Model，简称JMM）。内存模型把内存分为线程工作内存和主内存。加了volatile修饰的变量就会直接利用本地内存，这样多个线程set操作会直接从线程内存同步到主内存，get操作会直接从主内存同步到线程内存。
JMM的三个核心特性包括：

可见性：确保一个线程对共享变量的修改能够及时地被其他线程观察到。例如，使用volatile关键字修饰的变量，可以保证对该变量的读写操作对所有线程都是即时可见的。

原子性：确保操作是不可分割的，即当一个线程执行原子操作时，其他线程不能插入执行其他操作。Java中的原子操作包括对基本数据类型的赋值操作，以及synchronized块或方法。

有序性：JMM通过happens-before关系来确保操作的有序性。如果一个操作A happens-before 操作B，那么在执行操作B之前，操作A的结果已经对操作B可见，且操作A的执行顺序在操作B之前。

指令重排序破坏了可见性和有序性。
参考：https://www.jianshu.com/p/a67dc1c11088
双层校验锁：https://www.jianshu.com/p/c6a42c543abf

线程的生命周期

https://www.jianshu.com/p/c22ff5cc4a8f

synchronized底层实现？锁升级？

https://blog.youkuaiyun.com/qq_32907195/article/details/108906260
https://blog.youkuaiyun.com/m0_69519887/article/details/138546440
https://xiaolincoding.com/interview/juc.html#synchronized%E5%92%8Creentrantlock%E5%8F%8A%E5%85%B6%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF
https://blog.youkuaiyun.com/zhouzhenghu123/article/details/140086311
https://cloud.tencent.com/developer/article/1911691
利用对象实现锁，每个对象都有一个相关联的监视器（monitor），监视器有4个重要的变量，计数器、当前线程，waitSet和entryList。

JDK 1.6 之前，synchronized 是重量级锁。JDK 1.6 之前，synchronized 是重量级锁，为了优化，就有了锁升级

处理锁升级还有其他优化手段，锁消除、锁粗化、锁自旋。
synchronized 核心优化方案主要包含以下 4 个：

锁膨胀：synchronized 从无锁升级到偏向锁，再到轻量级锁，最后到重量级锁的过程，它叫做锁膨胀也叫做锁升级。JDK 1.6 之前，synchronized 是重量级锁，也就是说 synchronized 在释放和获取锁时都会从用户态转换成内核态，而转换的效率是比较低的。但有了锁膨胀机制之后，synchronized 的状态就多了无锁、偏向锁以及轻量级锁了，这时候在进行并发操作时，大部分的场景都不需要用户态到内核态的转换了，这样就大幅的提升了 synchronized 的性能
。
锁消除：指的是在某些情况下，JVM 虚拟机如果检测不到某段代码被共享和竞争的可能性，就会将这段代码所属的同步锁消除掉，从而到底提高程序性能的目的。（比如单线程使用某些线程安全的容器，有可能不会加锁；实现是JIT 即时编译时，通过对运行上下文的扫描，经过逃逸分析，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间）

锁粗化：将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁。（加锁解锁也需要消耗资源）

自适应自旋锁：指通过自身循环，尝试获取锁的一种方式，优点在于它避免一些线程的挂起和恢复操作，因为挂起线程和恢复线程都需要从用户态转入内核态，这个过程是比较慢的，所以通过自旋的方式可以一定程度上避免线程挂起和恢复所造成的性能开销。

内核态和用户态

https://www.jianshu.com/p/011f4062d372
用户态和内核态是程序运行的两种状态，
线程调度部分操作底层也会依赖操作系统，比如重量级锁，会依赖操作系统的。这个时候就相当于从用户态切换到内核态，然后获取到锁，又会切回来，这个过程是耗时操作。轻量级锁都是在用户态直接完成，不用惊动操作系统，是一种优化手段。
JVM对于os kernel来说呢就相当于是一个普通的应用程序，那么你想申请一把锁，对线程进行调度。实现这件事的时候需要向操作系统内核申请，操作系统内核帮你管理这些线程，管理好了之后反馈给你。这个过程简单来说就是 从用户态到内核态的访问，访问完了由内核态再反馈回来，这个就叫重量级锁。

逃逸分析

https://blog.youkuaiyun.com/sky15256567734/article/details/106786870
逃逸分析（Escape Analysis）是编译器优化技术中的一种，它用于分析对象的作用域，判断对象是否在方法中创建后，被外部方法所引用或者作为参数传递到其他方法中。基于这种分析，编译器可以进行一些优化，比如：

栈上分配：如果一个对象不会逃逸到方法之外，那么编译器可以将这个对象的内存分配从堆内存转移到栈内存。由于栈内存的分配和回收速度通常比堆内存快，这样可以提高程序的运行效率。

同步省略：如果一个对象不会被其他线程访问，即不会逃逸到线程之外，那么编译器可以省略对这个对象的同步操作，从而提高性能。

标量替换：对于不会逃逸的对象，如果其内部状态不需要封装在对象中，编译器可以将其替换为基本类型的集合，即标量。这样可以减少内存分配和提高缓存的局部性。

死代码消除：如果分析出某些代码路径不会执行，编译器可以将其优化掉。

在Java中，逃逸分析对于实现即时编译器（JIT）中的优化至关重要，尤其是在运行时编译的环境下，如HotSpot虚拟机。通过逃逸分析，JIT编译器能够在运行时决定是否可以应用上述优化。

需要注意的是，逃逸分析并不是在所有的场景下都能带来性能提升，有时候过度优化可能会导致代码膨胀，甚至因为优化错误而引入bug。因此，编译器在进行逃逸分析时需要权衡优化的收益和风险。

synchronized 和 lock的区别

https://tech.meituan.com/2019/12/05/aqs-theory-and-apply.html

AQS

https://www.cnblogs.com/wang-meng/p/12816829.html
AQS(AbstractQueuedSynchronizer)，所谓的AQS即是抽象的队列式的同步器，内部定义了很多锁相关的方法，我们熟知的ReentrantLock、ReentrantReadWriteLock、CountDownLatch、Semaphore等都是基于AQS来实现的。

ReentrantReadWriteLock

https://xie.infoq.cn/article/66eccf311694e47693183a665
https://segmentfault.com/a/1190000015768003

CountDownLatch

https://www.jb51.net/program/292519yrv.htm

Semaphore

https://blog.youkuaiyun.com/crazymakercircle/article/details/109406154

ThreadLocal

https://segmentfault.com/a/1190000041645905
threadlocal 为什么有内存泄漏风险
https://xie.infoq.cn/article/a61f9a723d0d74ac5a876726a

ConcurrentHashMap

jdk1.7 锁分段、分段锁，Segment
jdk1.8放弃了分段锁，采用cas+synchronized 锁保证
https://www.jianshu.com/p/e0711142132f
https://zhuanlan.zhihu.com/p/62110112
https://www.jianshu.com/p/1197e4717194

可中断锁

https://blog.youkuaiyun.com/m0_50116974/article/details/140164578

怎么使用多线程？

继承Thread、实现Runnable接口、实现Callable接口（可以根据FutureTask拿到返回结果）、线程池
参考：
https://zhuanlan.zhihu.com/p/334737925
https://www.cnblogs.com/java1024/p/11950129.html
https://blog.youkuaiyun.com/weixin_44797490/article/details/91006241

线程池怎么用？原理？执行流程是咋样的？

https://zhuanlan.zhihu.com/p/143269943
https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

服务重启，线程池里面的任务怎么办

https://blog.youkuaiyun.com/ameng734086045/article/details/87977246
https://blog.youkuaiyun.com/ksws01/article/details/110845897
必然导致线程池中积压的任务会丢失

本问题主要考察如何解决线程池中任务丢失的问题，要想办法把任务信息入库

如果要提交一个任务到线程池里去，在提交之前，可以将当前任务信息插入数据库，更新他的状态：未提交、已提交、已完成。提交成功后，更新他的状态为已提交状态。

系统重启，后台线程去扫描数据库里的未提交和已提交状态的任务，可以把任务信息读出来，重提交到线程池里，继续进行执行

在服务重启时保证线程池中的任务不丢失，通常需要采取一些策略来管理和维护任务的状态。以下是一些常用的方法：

1. 持久化任务队列：

   • 将任务队列中的任务持久化存储，例如存储在数据库或分布式缓存中。
   • 服务重启后，重建线程池，并从持久化存储中恢复任务队列。

2. 使用持久化线程池：

   • 使用支持持久化任务的线程池实现，如某些第三方库提供的持久化线程池。
   • 这些线程池可以在服务重启后，自动从持久化存储中恢复任务并继续执行。

3. 任务恢复机制：

   • 在任务执行前，记录任务的执行状态和进度。
   • 服务重启后，检查上次的执行状态，对于未完成的任务，根据记录的状态进行恢复。

4. 任务幂等性：

   • 设计任务为幂等性，即多次执行相同的任务不会影响最终结果。
   • 服务重启后，即使重新执行了部分任务，也不会导致数据不一致。

5. 分布式任务队列：

   • 使用分布式任务队列，如 RabbitMQ、Kafka 或 Amazon SQS。
   • 这些系统可以保证任务的持久化和可靠性，即使服务重启，任务也不会丢失。

6. 定时任务重试：

   • 对于定时执行的任务，可以在服务重启后重新计算下次执行时间，并重新安排执行。

7. 事务性重启：

   • 在服务重启前，将当前执行的任务状态保存到事务日志中。
   • 重启服务时，先回滚事务，恢复任务状态，然后再重启服务。

8. 使用 Spring 框架的 Scheduled 任务：

   • 如果使用 Spring 框架，可以利用 @Scheduled 注解的定时任务。
   • Spring Boot 支持在应用重启后自动重新调度这些任务。

9. 自定义线程池关闭策略：

   • 在关闭线程池时，可以自定义关闭策略，确保所有任务完成后再关闭线程池。
   • 使用 shutdown() 方法等待任务完成，而不是立即使用 shutdownNow() 强制关闭。

10. 监控和告警：

    • 实现监控机制，监控任务执行状态和线程池状态。
    • 在任务丢失或线程池异常时，及时发出告警，以便快速响应。

在实际应用中，可能需要根据业务需求和系统架构选择合适的策略或组合使用多种策略，以确保服务重启时线程池中的任务不丢失。