JAVA基础-线程(Thread)、多线程（Multi-threaded）
1、知识铺垫
要想了解什么是线程，首先要搞明白线程与进程的区别，并行与并发的区别
1.1 线程与进程
进程：是指⼀个内存中运⾏的应⽤程序，每个进程都有⼀个独⽴的内存空间，⼀个应⽤程序可以同时运⾏多个进程；进程也是程序的⼀次执⾏过程，是系统运⾏程序的基本单位；系统运⾏⼀个程序即是 ⼀个进程从创建、运⾏到消亡的过程。
线程：线程是进程中的⼀个执⾏单元，负责当前进程中程序的执⾏，⼀个进程中⾄少有⼀个线程。⼀个进程中是可以有多个线程的，这个应⽤程序也可以称之为多线程程序。
简⽽⾔之：⼀个程序运⾏后⾄少有⼀个进程，⼀个进程中可以包含多个线程
1.2 并行与并发
并发：指两个或多个事件在同⼀个时间段内发⽣。
并⾏：指两个或多个事件在同⼀时刻发⽣（同时发⽣）。
在操作系统中，安装了多个程序，并发指的是在⼀段时间内宏观上有多个程序同时运⾏，这在单 CPU 系统中，每⼀时刻只能有⼀道程序执⾏，即微观上这些程序是分时的交替运⾏，只不过是给⼈的感觉是同时运 ⾏，那是因为分时交替运⾏的时间是⾮常短的。
⽽在多个 CPU 系统中，则这些可以并发执⾏的程序便可以分配到多个处理器上（ CPU ），实现多任务并⾏ 执⾏，即利⽤每个处理器来处理⼀个可以并发执⾏的程序，这样多个程序便可以同时执⾏。⽬前电脑市场 上说的多核 CPU ，便是多核处理器，核 越多，并⾏处理的程序越多，能⼤⼤的提⾼电脑运⾏的效率。
注意：单核处理器的计算机肯定是不能并⾏的处理多个任务的，只能是多个任务在单个 CPU 上并发运 ⾏。同理 , 线程也是⼀样的，从宏观⻆度上理解线程是并⾏运⾏的，但是从微观⻆度上分析却是串⾏ 运⾏的，即⼀个线程⼀个线程的去运⾏，当系统只有⼀个 CPU 时，线程会以某种顺序执⾏多个线程， 我们把这种情况称之为线程调度。
2、线程
2.1 创建线程的方式
- 继承Thread类并重写run()方法。
- 实现Runnable接口并重写run()方法。将Runnable实例作为Thread类的构造函数参数传递并启动线程。
- 实现Callable接口并重写call()方法。使用ExecutorService的submit()方法提交Callable任务，并通过Future对象获取返回值。
- 线程池创建
2.1.1 Runnable 和 Callable 的区别
Runnable 接口 run 方法无返回值,且无法捕获处理异常;
Callable 接口 call 方法有返回值，支持泛型, 可以获取异常信息
2.2 线程的状态
NEW（新建）
RUNNABLE（运行）
BLOCKED（阻塞）
WAITING（等待）
TIME_WAITING（超时等待）
TERMINATED （终止）
2.3 线程的相关方法
- 线程等待（wait）：会释放对象的锁（进入waiting）
- 线程睡眠（sleep）：不会释放当前占有的锁（进入time-waiting）
- 线程让步（yield）：与其他线程一起重新竞争CPU 时间片
- 线程中断（interrupt）：线程在合适的时候中断
- Join 等待其他线程终止：则当前线程转为阻塞状态，会到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待 cpu 的宠幸
- .线程唤醒（notify）
2.3.1 wait()和 sleep()的区别
| wait() | sleep() | |
| 来自的类 | Object 类 | Thread 类 |
| 锁的释放 | 在等待的过程中会释放锁 | 在等待的过程中不会释放锁 |
| 使用范围 | 必须在同步代码块中使用 | 可以在任何地方使用 |
2.3.2 run()与start()方法
run() 方法是线程的执行体，线程启动后会执行 run() 方法中的代码，当 run() 方法执行完毕后
start() 方法用于启动一个新线程，它会创建一个新的线程，并在新的线程中执行 run() 方法中的代码。在调用 start() 方法的时候，JVM 会为新的线程分配资源，并执行该线程中的 run() 方法。
2.4 ThreadLocal（token、localdate、traceid）
线程级别的存储工具，是一个线程本地变量，为每一个线程都创建一个私有的变量，每个线程只能获取到自己的变量，从而避免了线程安全问题，是一个线程级别的哈希表，用于存储每个线程的变量。ThreadLocalMap 以 ThreadLocal 对象作为 key，以变量值作为 value，每个线程都可以通过 ThreadLocalMap 获取自己的变量
2.4.1 ThreadLocal使用场景
- 需要保存线程的上下文信息，例如 用户信息，通过token解析出来的用户id等
- 需要对线程的局部变量进行隔离，避免线程安全问题； LocalDate LocalDateTime
- 需要在跨类跨方法使用同一个变量，同时又不希望使用全局变量的情况；
- 需要避免传递参数的繁琐，例如在 Spring 框架中使用的事务管理。
2.4.2 ThreadLocal注意事项
每次使用后都要使用remove()删除数据
不不然会造成内存泄露，进而造成内存溢出
2.4.5 内存泄漏和内存溢出
- 内存泄漏：对象使用之后，并没有释放，内存一直被占用，业务代码频繁执行之后，大量这样的对象不被回收，造成可用的内存空间越来越少，最终造成内存溢出。通俗点讲就是 不用的垃圾没有丢掉.
- 内存溢出：当创建的对象的大小大于可用的内存容量大小。
3 、多线程
3.1 多线程的基本知识
多线程是计算机多任务处理的一种方式，它允许单个程序中同时运行多个任务。在多线程模型中，每个线程代表执行流程中的一个独立的任务，它们可以并行处理以提高效率。
在操作系统中，进程是资源分配的基本单位，而线程是程序执行的最小单位。一个进程可以包含多个线程，每个线程执行不同的任务。多线程的出现，使得程序可以同时执行多个任务，例如，一个文本编辑器可以在保存文件的同时继续接受用户的输入。
多线程与单线程相比，最大的优势在于可以并行处理任务，提高资源利用率和程序响应速度。例如，一个网络服务器可以同时处理多个客户端请求，而不是一次处理一个。
4、线程池
线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制：它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可
4.1 线程池的工作原理
当一个任务提交至线程池之后，
1. 线程池首先判断核心线程池里的线程是否已经满了。如果不是，则创建一个新的工作线程来执行任务。否则进入 2.
2. 判断工作队列是否已经满了，倘若还没有满，将任务放入队列。否则进入 3.
3. 判断线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行。
如果线程池满了，则交给饱和策略来处理任务。
4.1.2 线程池主要优点
- 降低资源消耗（复用线程，减少线程频繁新建、销毁等带来的开销）
- 提高响应速度
- 提高线程的可管理性
4.1.2 阿里巴巴不推荐使用JDK自带线程池的原因
同时，阿里巴巴在其《Java开发手册》中也强制规定：线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
阿里巴巴开发手册为什么禁止使用
Executors去创建线程池，原因就是newFixedThreadPool()和newSingleThreadExecutor()两个方法允许请求的最大队列长度是Integer.MAX_VALUE，可能会出现任务堆积，出现OOM。newCachedThreadPool()允许创建的线程数量为Integer.MAX_VALUE，可能会创建大量的线程，导致发生OOM。它建议使用ThreadPoolExecutor方式去创建线程池，通过上面的分析我们也知道了其实Executors三种创建线程池的方式最终就是通过ThreadPoolExecutor来创建的，只不过有些参数我们无法控制，如果通过ThreadPoolExecutor的构造器去创建，我们就可以根据实际需求控制线程池需要的任何参数，避免发生OOM异常。
4.2 使用线程池-线程池的创建方式
线程池的创建方法总共有 7 种，但总体来说可分为 2 类：
通过 ThreadPoolExecutor 创建的线程池
通过 Executors 创建的线程池
线程池的创建方式总共包含以下 7 种（其中 6 种是通过 Executors 创建的，1 种是通过 ThreadPoolExecutor 创建的）：
- Executors.newFixedThreadPool()：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待；
- Executors.newCachedThreadPool()：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收多余的线程，若线程数不够，则新建线程；
- Executors.newScheduledThreadPool()：创建一个可以执行延迟任务的线程池；
- Executors.newSingleThreadExecutor()：创建单个线程数的线程池，它可以保证先进先出的执行顺序；
- Executors.newSingleThreadScheduledExecutor()：创建一个单线程的可以执行延迟任务的线程池；
- Executors.newWorkStealingPool()：创建一个抢占式执行的线程池（任务执行顺序不确定）JDK 1.8 添加
- ThreadPoolExecutor：最原始的创建线程池的方式，它包含了 7 个参数可供设置
单线程池的意义： 虽然 newSingleThreadExecutor 和 newSingleThreadScheduledExecutor 是单线程池，但提供了工作队列，生命周期管理，工作线程维护等功能。
4.3 线程池的参数
参数代表的含义如下：
- corePoolSize：核心线程数，线程池中始终存活的线程数。
- maximumPoolSize：最大线程数，线程池中允许的最大线程数，当线程池的任务队列满了之后可以创建的最大线程数。
- keepAliveTime：最大线程数可以存活的时间，当线程中没有任务执行时，最大线程就会销毁一部分，最终保持核心线程数量的线程。
unit：单位是和参数 3 存活时间配合使用的，合在一起用于设定线程的存活时间。参数 keepAliveTime 的时间单位有以下 7 种可选：
- TimeUnit.DAYS：天
- TimeUnit.HOURS：小时
- TimeUnit.MINUTES：分
- TimeUnit.SECONDS：秒
- TimeUnit.MILLISECONDS：毫秒
- TimeUnit.MICROSECONDS：微妙
- TimeUnit.NANOSECONDS：纳秒
- workQueue：一个阻塞队列，用来存储线程池等待执行的任务，均为线程安全。
它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种，包含以下 7 种类型：
- ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。
- LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。
- SynchronousQueue：一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
- PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
- DelayQueue：一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素
- LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似，还含有非阻塞方法。
- LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
较常用的是 LinkedBlockingQueue 和 Synchronous，线程池的排队策略与 BlockingQueue 有关
threadFactory：线程工厂，主要用来创建线程。
handler：拒绝策略，拒绝处理任务时的策略，系统提供了 4 种可选：
- AbortPolicy中止策略（默认）：拒绝并抛出异常。
- CallerRunsPolicy调用者运行策略：使用当前调用的线程来执行此任务。
- DiscardOldestPolicy丢弃最旧任务策略：抛弃队列头部（最旧）的一个任务，并执行当前任务。
- DiscardPolicy丢弃策略：忽略并抛弃当前任务。
4.4 线程池的状态
1. 初始状态：线程池被创建时，里面并没有任何线程。此时线程池的状态为初始状态。
2. 运行状态：当向线程池中提交任务后，线程池中的线程开始执行任务，此时线程池的状态为运行状态。
3. 阻塞状态：当线程池中的任务队列已满，无法再接受新的任务时，线程池会进入阻塞状态，等待任务队列中的任务被执行完毕后再接受新的任务。
4. 关闭状态：当调用线程池的shutdown()方法时，线程池会进入关闭状态，此时线程池不再接受新的任务，但会执行任务队列中的任务。
5. 停止状态：当调用线程池的shutdownNow()方法时，线程池会进入停止状态，此时线程池不再接受新的任务，并且会中断正在执行的任务。
6. 终止状态：当线程池中所有的任务都执行完毕后，线程池会进入终止状态，此时线程池中不再有任何线程。
4.4.1 shutdownNow与shutdown的区别
1、shutdownNow 首先将线程池的状态设置为 STOP,然后尝试停止所有的正在执行和未执行任务的线程，并返回等待执行任务的列表；
2、shutdown 只是将线程池的状态设置为 SHUTDOWN 状态，然后中断所有没有正在执行任务的线程，继续执行正在执行的任务，直到任务结束.
5 、线程死锁
5.1 死锁
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法继续执行
5.1.1 死锁的产生的条件(4者缺一不可)
- 互斥条件:一个资源一次只能被一个线程持有，如果其他线程想要获取该资源，就必须等待该线程释放该资源。
- 保持条件:一个线程请求资源时，如果已经持有了其他资源，就可以保持对这些资源的控制，直到满足所有资源的要求才释放
- 不剥夺条件:已经分配的资源不能被其他线程剥夺，只能由持有资源的线程释放
- 环路等待条件:个线程形成一种循环等待的关系，每个线程都在等待其他线程所持有的资源，从而导致死锁的产生。
5.1.2 如何避免死锁
避免死锁
- 尽量避免使用多个锁
- 减少锁的粒度:确保同步代码块的执行时间尽可能短，这样可以减少线程等待时间，
- 使用尝试锁:通过 ReentrantLock.tryLock() 方法可以尝试获取锁
- 避免嵌套锁
6、Synchronized同步锁
会使用对象的内置锁（也称为监视器锁）来实现同步，每个对象都有一把内置锁，当一个线程访问一个同步代码块时，它会尝试获取这个锁，如果锁被其他线程持有，则该线程将被阻塞，直到锁被释放
- 互斥性（一个线程拿锁，其他线程不能拿锁）
- 可重入性（同一个线程可以多次获取同步锁）
- 独占性（一个线程获得了对象的锁，则其他线程必须等待该线程释放锁之后才能获取锁。）
- 缺点：非公平锁
6.2 synchronized静态方法和非静态方法的区别
- 当 synchronized 修饰非静态方法时，它实际上是对调用该方法的对象实例进行加锁。这意味着如果有多个线程尝试访问同一个对象实例的不同 synchronized 非静态方法，它们将被串行执行，因为这些线程需要获取同一个对象锁。
- synchronized 修饰静态方法时：它锁定的是类的Class对象，这意味着无论哪个线程访问该类的任何静态同步方法，都需要获取这个类的锁。因此，即使是不同的对象实例，只要它们调用的是同一个类的静态同步方法，这些调用也必须排队执行。
6.3 Synchronized与lock的区别
| 区别 | Synchronized与lock | Lock（reentrantlock） |
| 类型 | 关键字 | 接口 |
| 加锁方式 | 隐藏的加锁 | 显示的加锁 |
| 作用域 | 作用于方法上面 | 只能用于方法块上面 |
| 底层 | 对象内置锁 | AQS(AbstractQueuedSynchronizer 抽象队列同步器) |
| 锁类型 | 非公平锁 | 可选择非公平或公平锁 |
6.4 锁的升级
6.4.1 基本概念
无锁 （用户）-> 偏向锁（用户） -> 轻量级锁（用户端） -> 重量级锁
这是Java中针对synchronized锁的一种优化策略，它描述了锁状态可能经历的四个阶段，但并不是所有Java虚拟机都实现了这四个阶段，特别是偏向锁和轻量级锁的实现可能因JVM版本而异。
对象刚创建是无锁状态，当第一个线程访问同步代码块时，升级为偏向锁，当第二个线程进来的时候，第二个线程会其实就是自旋锁，等待第一个线程释放锁，多线程压力比较大的时候用重量级锁（互斥锁）
6.4.2 锁升级过程
a. 无锁状态
对象刚创建时，并没有锁的介入，这时处于无锁状态。
b. 偏向锁（Biased Locking）
只需要用一个CAS操作和简单地判断比较，就可以让一个线程持续地拥有一个锁。
c. 轻量级锁
就像偏向锁的前提，是同步代码块在大多数情况下只有同一个线程访问的时候。
而轻量级锁的前提则是，线程在同步代码块里面的操作非常快，获取锁之后，很快就结束操作，然后将锁释放出来。
d. 重量级锁
相比起轻量级锁，再膨胀的锁，一般称之为重量级锁，因为是依赖于每个对象内部都有的monitor锁来实现的，而monitor又依赖于操作系统的MutexLock(互斥锁)来实现，所以一般重量级锁也叫互斥锁
7、JUC包
JUC是java.util.concurrent包的简称，用于处理并发编程的工具包
同步工具：
- CountDownLatch（倒计时锁存器）、CyclicBarrier（循环屏障）、StampedLock（信号量）
并发集合：
- CurrentHashMap、CopyOnWriteLock、BlockingQueue
原子操作(cas原理)：
- AtomicInteger、AtomicLong
锁：
- synchronized、ReentrantLock（重入锁）、ReentrantReadWriteLock（重入读写锁）、StampedLock（乐观读写锁）
原文地址：https://blog.csdn.net/m0_74007708/article/details/142689740
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！