Java多线程那些事，对Java并发编程2w余字的总结，超详细（从入门到完全掌握）
目录
-
- 1.前言
-
- 1.1.进程与线程之间的关系以及管程
-
- 1.1.1.进程
- 1.1.2.线程
- 1.1.3.进程与线程的比较
- 1.1.4.管程
- 1.2.并发与并行的区别
- 1.3.同步与异步的区别
- 1.4.阻塞非阻塞
- 2.Java线程的创建
-
- 2.1.线程的创建和使用
-
- 2.1.1.Thread类
- 2.2.创建多线程的五种方法
-
- 2.2.1.继承Thread类的方式
- 2.2.2.实现Runnable接口
- 2.2.3 实现Callable接口(JDK 5.0新增)
- 2.2.4.使用CompletableFuture(JDK 8.0新增)
- 2.2.5.使用线程池
- 2.3.Thread类的相关方法
- 3.线程的调度、优先级、分类和生命周期
-
- 3.1.线程的调度
- 3.2.线程的优先级
- 3.3.线程的分类
- 3.4.线程的生命周期
- 4.线程的同步
-
- 4.1.同步代码块
-
- 4.1.1同步代码块解决继承Thread类方式的线程安全问题
- 4.1.2同步代码块解决实现Runnable接口方式的线程安全问题
- 4.2.同步方法
-
- 4.2.1使用同步方法处理继承Thread类方式中的线程安全问题
- 4.2.2使用同步方法解决实现Runnable接口的线程安全问题
- 4.3.Lock（锁）
- 4.4.synchronized 与 Lock 的对比
- 4.5.释放锁和不会释放锁的操作
- 5.线程的通信
-
- 5.1wait() 、 notify() 和 notifyAll()
- 5.2.CountDownLatch
- 6.并发编程
1.前言
现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，例如：
在听歌的时候同时打游戏，并且时不时还回复一下微信或者qq。操作系统是如何做到这些的呢？
原来CPU执行代码都是一条一条顺序执行的，但是，即使是单核cpu，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行；例如，让游戏执行0.001秒，让微信或者qq执行0.001秒，再让音乐播放器执行0.001秒，在人看来，CPU就是在同时执行多个任务。并且即使是多核CPU，因为通常任务的数量远远多于CPU的核数，所以任务也是交替执行的。
1.1.进程与线程之间的关系以及管程
了解到这里，首先我们先要知道，进程与线程之间的关系，以及cup是如何进行调度，共享资源的。
1.1.1.进程
进程就是操作系统中执行的一个程序，操作系统以进程为单位分配存储空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为它们合理的分配资源。
1.1.2.线程
一个进程还可以拥有多个并发的执行线索，简单的说就是拥有多个可以获得CPU调度的执行单元，这就是所谓的线程。由于线程在同一个进程下，它们可以共享相同的上下文，因此相对于进程而言，线程间的信息共享和通信更加容易。当然在单核CPU系统中，真正的并发是不可能的，因为在某个时刻能够获得CPU的只有唯一的一个线程。下图中，图一为进程与线程之间的关系,图二为x86CPU的架构图，图三为CPU中寄存器（Thread可以看作是某个线程正在使用的寄存器）与三级缓存、主存之间的结构图。大家可以好好看看图，精华之于图中。
图一为进程与线程之间的关系
图二为x86CPU的架构图
图三为CPU中寄存器（Thread可以看作是某个线程正在使用的寄存器）与三级缓存、主存之间的结构图。
结合着上面三个图看，进行理解，1.1.3章节内容也可以结合着上面的三张图来进行理解消化。
- 进程就是操作系统中执行的一个程序，操作系统以进程为单位分配存储空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为它们合理的分配资源。
- 一个进程还可以拥有多个并发的执行线索，简单的说就是拥有多个可以获得CPU调度的执行单元，这就是所谓的线程。由于线程在同一个进程下，它们可以共享相同的上下文，因此相对于进程而言，线程间的信息共享和通信更加容易。当然在单核CPU系统中，真正的并发是不可能的，因为在某个时刻能够获得CPU的只有唯一的一个线程。
- 这里不考虑超线程技术，因为每个CPU核心里算术逻辑运算单元ALU（Arithmetic and Logic Unit），浮点运算单元FPU（Floating Point Unit）这些运算单元的数量是有限的，而超线程的目的之一就是在一个线程用运算单元少的情况下，让另外一个线程跑起来，不让运算单元闲着。
1.1.3.进程与线程的比较
结合着上面的三个图看，进行理解
- 单核cpu每次只能执行某个进程中的某一个线程，一个进程可以拥有多个线程。
- 进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。
- 每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。
- 操作系统能让多核CPU同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）。系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。
- 没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（通过CPU调度，在每个时间片中只有一个线程执行）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
- 创建进程比创建线程开销大。
- 进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。
- 多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。
1.1.4.管程
- 管程(Monitor)，管程”一词翻译自英文Monitor Procedures，字面理解就是管理一个或多个执行过程。
- Monitor本质上是对通用同步工具的一种抽象，它就像一个线程安全的盒子，用户程序把一个方法或过程(代码块)放进去，它就可以为他们提供一种保障：同一时刻只能有一个进程/线程执行该方法或过程，从而简化了并发应用的开发难度。
- 如果Monitor内没有线程正在执行，则线程可以进入Monitor执行方法，否则该线程被放入入口队列(entry queue)并使其挂起。当有线程从Monitor中退出时，会唤醒entry queue中的一个线程。
- Java monitor机制通过synchronized关键字暴露给用户，syncronized可以修饰方法或代码块（两者本质上都是一个过程），JDK1.5新增 Lock 锁。
1.2.并发与并行的区别
- 并发：在一个时间段内发生若干事件；
- 并行：在同一时刻发生若干事件；
- 比如单核CPU，多个进程是以并发方式运行的，因为只有一个CPU，各个进程分别占用一段时间(如果某个进程中还有多个线程，那么再把进程分得的时间对每个线程再进行分配)，再切换到其他进程，等到下一次CPU使用权时再次执行未完成的任务，使用多核CPU时，可以将任务分配到不同的核同时运行，实现并行。
- 再比如上述1.1中提到的，多核cpu能并行运行多个进程，而在某一个进程中是并发运行多个线程的(通过CPU调度，在每个时间片中只有一个线程执行,因为每个时间片对于人而言很短，所以在人来看来是同时执行的)。并且即使是多核CPU，因为通常进程的数量远远多于CPU的核数，所以进程也存在交替执行。
- 不仅进程间可以并发执行，线程之间也可以并发执行。但是由于进程的创建、撤消和切换，系统的开销比较大，所以创建的进程数目不能太多，而线程的划分尺度比进程小，所以并发性比进程高，效率和吞吐量都比较高。
1.3.同步与异步的区别
同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication)。
- 同步指的是并发或并行的各个任务不是独自运行的，任务之间有一定的顺序，下一个任务需要等上一个任务的结果后才会运行；
- 也就是说同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。
- 异步是并发或并行的各个任务是相互独立的，一个任务不受另一个任务的影响；
- 而异步一旦开始，方法调用就会立即返回，调用者就可以继续后续的操作。而异步方法通常会在另外一个线程中，“真实”地执行着。整个过程，不会阻碍调用者的工作。
1.4.阻塞非阻塞
阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
- 阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
- 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。
2.Java线程的创建
在使用多线程之前我们需要明白它的意义，为何使用多线程原因如下：
- 提高效率，增加任务的吞吐量
- 提升CPU等资源的利用率，减少CPU的空转
注意点：
- CPU 密集型任务：
对于 CPU 密集型计算，多线程本质上是提升多核 CPU 的利用率，所以对于一个 8 核的 CPU，每个核一个线程，理论上创建 8 个线程就可以了。 - IO 密集型任务：
对于 IO 密集型任务最大线程数一般会大于 CPU 核心数很多倍，因为 IO 读写速度相比于 CPU 的速度而言是比较慢的，如果我们设置过少的线程数，就可能导致 CPU 资源的浪费。而如果我们设置更多的线程数，那么当一部分线程正在等待 IO 的时候，它们此时并不需要 CPU 来计算，那么另外的线程便可以利用 CPU 去执行其他的任务，互不影响，这样的话在任务队列中等待的任务就会减少，可以更好地利用资源。
Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。和单线程相比，多线程编程的特点在于：多线程经常需要读写共享数据，并且需要同步。下面我将详细介绍Java多线程的用法。
2.1.线程的创建和使用
2.1.1.Thread类
- Java虚拟机允许程序运行多个线程，它通过java.lang.Thread 类来体现。
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
- Thread类的构造器(在Java8中，共有9个构造器，它们都是调用init方法进行线程的初始化的，以下简要介绍其中的4个)：
- Thread():创建新的Thread对象
- Thread(String threadName):创建线程并指定线程实例名
- Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接口中的run方法
- Thread(Runnable target, String name):创建新的Thread对象
2.2.创建多线程的五种方法
- 继承Thread类的方式
- 实现Runnable接口的方式
- 实现Callable接口(JDK 5.0新增)
- 使用CompletableFuture(JDK 8.0新增)
- 使用线程池
2.2.1.继承Thread类的方式
步骤为以下4步骤：
- 创建一个继承于Thread类的子类
- 该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
- 创建该子类的对象
- 通过该子类对象调用start()
代码示例：
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
//2. 该子类重写Thread父类的run() 方法，将线程执行的操作声明在run()中
// 这里我以输出100以内的质数为例
@Override
public void run() {
label:for (int i = 2; i < 100; i++) {
for(int j = 2; j < Math.sqrt(i);j++){
if(i % j == 0){
continue label;
}
}
System.out.println(Thread.currentThread().getName()+":质数"+i);
}
}
}
public class ThreadTestByInherit {
public static void main(String[] args) {
//3. 创建该子类的对象
MyThread myThread = new MyThread();
//4. 通过该子类对象调用start()
myThread.start();
//如果直接调用run(),是main线程，没有达到多线程的目的
//myThread.run();
//主线程输出
System.out.println(Thread.currentThread().getName()+"：我是主线程");
}
}
输出结果：
main：我是主线程
Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
Thread-0:质数5
...省略...
Process finished with exit code 0
注意点：
- 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
- run()方法由JVM调用，什么时候调用，执行的过程控制都由操作系统的CPU调度决定。
- 想要启动多线程，必须调用start方法。
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”。
2.2.2.实现Runnable接口
步骤为以下5个步骤：
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()
代码示例：
//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
label:for (int i = 2; i < 100; i++) {
for(int j = 2; j < Math.sqrt(i);j++){
if(i % j == 0){
continue label;
}
}
System.out.println(Thread.currentThread().getName()+":质数"+i);
}
}
}
public class ThreadTestByRunnable {
public static void main(String[] args) {
//3. 创建实现类的对象
MThread mThread = new MThread();
//4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread thread = new Thread(mThread);
//5. 通过Thread类的对象调用start()
thread.start();
}
}
输出结果：
Thread-0:质数2
Thread-0:质数3
Thread-0:质数4
...省略...
Process finished with exit code 0
上述两种方式的比较
- 继承Thread：线程代码存放在Thread子类run方法中。
- 实现Runnable：线程代码存放在接口实现类的run方法中。
- 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
- 在开发中，优先选择实现Runnable接口的方式
- 因为实现的方式没有类的单继承性的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
2.2.3 实现Callable接口(JDK 5.0新增)
- 与使用Runnable相比， Callable功能更强大些
- Callable规定的方法是call(),Runnable规定的方法是run().
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 通过与Future的结合，可以实现利用Future来跟踪异步计算的结果。
- 需要借助FutureTask类，比如获取返回结果
- Future接口(总共有五个方法)
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- 当计算完成后，只能通过get()方法得到结果。
- get有两个重载方法，get()：获取结果，get方法会阻塞直到结果准备好了；get(long timeout, TimeUnit unit)：获取结果，但只等待指定的时间。
- 调用cancel()方法可以取消，但是一旦计算完成了，那么这个计算就不能被取消。
- isCancelled()方法，如果此任务在正常完成之前被取消，则返回true。
- isDone()方法，如果此任务已完成，则返回true。完成可能是由于正常终止、异常或取消——在所有这些情况下，此方法将返回true。
- FutrueTask类
- FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口。它同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
输出结果：
2
4
6
8
...省略...
94
96
98
100
总和为：2550
Process finished with exit code 0
2.2.4.使用CompletableFuture(JDK 8.0新增)
- 使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待。当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 不过，有没有更好的解决方案呢？当然是有的。
- 从Java 8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。
- 它结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。
- CompletableFuture被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。
- 通过这种方式，我们的主线程不用为了任务的完成而阻塞/等待，我们可以用主线程去并发的执行其他的任务。 使用这种并发方式，极大地提升了程序的性能。
下面我们看一个简单例子：
static void runAsyncExample() {
CompletableFuture cf = CompletableFuture.runAsync(() -> {
assertTrue(Thread.currentThread().isDaemon());
randomSleep();
});
assertFalse(cf.isDone());
sleepEnough();
assertTrue(cf.isDone());
}
2.2.5.使用线程池
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
下面这张图很重要，线程池来了线程的流程会是按照如下的流程去执行，为方便大家观看，在下面的线程池讲解中也会多次出现该图。这里先放一张，加深大家的印象。
代码示例：
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPoolTest {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
但是呢，根据Java开发手册中的关于并发处理的建议：线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
为什么线程池不允许使用 Executors 去创建呢,这是因为:
CachedThreadPool 和 ScheduledThreadPool : 允许的创建线程数量为 Integer.MAX_VALUE(源码如下)，这是个数值已经非常大了，我们可以理解成无上限，当来新线程时，线程池按照上图执行，到第三个判断时，线程池是否已满，因为允许的创建线程数量为 Integer.MAX_VALUE，所以永远都是没满，就会一直创建新的线程，可能会创建大量的线程，从而导致 OOM。
FixedThreadPool 和 SingleThreadPool : 允许的请求队列长度为 Integer.MAX_VALUE（原来如下），这个值我们可以理解为无上限，当有新任务来时，线程池按照上图的流程进行执行，到第二个判断时，因为队列无上限，所以会一直判断没有满，就会讲来的所有任务都扔进队列里，从而导致 OOM。
这个地方Java官方工厂模式没有用好，很鸡肋。
所以推荐使用ThreadPoolExecutor 的方式，这些参数我们都可以自己进行设置，而不是使用官方已经提高好的默认参数，ThreadPoolExecutor构造方法如下：
ThreadPoolExecutor的七个参数：
- corePoolSize：线程池中核心线程数的最大值
- maximumPoolSize：线程池中能拥有最多线程数
- keepAliveTime：表示空闲线程的存活时间。
- TimeUnitunit：表示keepAliveTime的单位。
- handler：表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。
- threadFactory：指定创建线程的工厂
- workQueue：它决定了缓存任务的排队策略，如下两种：
- SynchronousQueue队列没有容量，如果核心线程数为0，任务来时，只能新建线程（如果没有空闲的线程），不能存放任务。也就是说对于提交的任务，如果有空闲线程，则使用空闲线程来处理；否则新建一个线程来处理任务。
- LinkedBlockingQueue：顾名思义是用链表实现的队列，可以是有界的，也可以是无界的，但在Executors中默认使用无界的。
线程池执行流程如下图（第三次出现该图了，哈哈哈，肿么样，印象深刻了吧，相信大家都已经记住这个流程了）：
2.3.Thread类的相关方法
- start():启动当前线程；调用当前线程的run()方法
- run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
- currentThread():静态方法，返回执行当前代码的线程
- getName():获取当前线程的名字
- setName():设置当前线程的名字
- yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。
- join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
- stop():已过时。当执行此方法时，强制结束当前线程，不推荐使用。
- sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
- isAlive():判断当前线程是否存活
代码示例：
class MyThreadClass extends Thread{
@Override
public void run() {
label:for (int i = 2; i < 100; i++) {
for(int j = 2; j < Math.sqrt(i);j++){
if(i % j == 0){
continue label;
}
}
System.out.println(Thread.currentThread().getName()+":质数"+i);
}
}
public MyThreadClass() {
super();
}
public MyThreadClass(String name) {
super(name);
}
}
public class ThreadMethodTest{
public static void main(String[] args) {
MyThreadClass thread0 = new MyThreadClass();
MyThreadClass thread1 = new MyThreadClass("线程二");
//getName():获取当前线程的名字
System.out.println(thread0.getName());
System.out.println(thread1.getName());
//setName():设置当前线程的名字
thread0.setName("线程一");
System.out.println();
System.out.println(thread0.getName());
System.out.println(thread1.getName());
//currentThread():静态方法，返回执行当前代码的线程
System.out.println(Thread.currentThread().getName());
//start():启动当前线程；调用当前线程的run()方法
thread0.start();
thread1.start();
//join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
try {
thread0.join();
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
//直接调用run方法，此时是主线程直接调用的
thread0.run();
//yield():暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若没有，继续执行当前线程。
Thread.yield();
//sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
//这里让主线程阻塞3秒
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//isAlive():判断当前线程是否存活
System.out.println(thread0.isAlive());
System.out.println(thread1.isAlive());
}
}
输出结果：
Thread-0
线程二
线程一
线程二
main
线程二:质数2
线程二:质数3
线程二:质数4
线程二:质数5
线程二:质数7
线程一:质数2
线程一:质数3
线程一:质数4
线程一:质数5
线程一:质数7
线程一:质数9
线程一:质数11
线程一:质数13
线程二:质数9
线程二:质数11
线程二:质数13
线程二:质数17
线程二:质数19
线程二:质数23
线程二:质数25
线程二:质数29
线程二:质数31
线程二:质数37
线程二:质数41
线程二:质数43
线程一:质数17
线程二:质数47
线程二:质数49
线程二:质数53
线程二:质数59
线程二:质数61
线程二:质数67
线程二:质数71
线程二:质数73
线程二:质数79
线程二:质数83
线程二:质数89
线程二:质数97
线程一:质数19
线程一:质数23
线程一:质数25
线程一:质数29
线程一:质数31
线程一:质数37
线程一:质数41
线程一:质数43
线程一:质数47
线程一:质数49
线程一:质数53
线程一:质数59
线程一:质数61
线程一:质数67
线程一:质数71
线程一:质数73
线程一:质数79
线程一:质数83
线程一:质数89
线程一:质数97
main:质数2
main:质数3
main:质数4
main:质数5
main:质数7
main:质数9
main:质数11
main:质数13
main:质数17
main:质数19
main:质数23
main:质数25
main:质数29
main:质数31
main:质数37
main:质数41
main:质数43
main:质数47
main:质数49
main:质数53
main:质数59
main:质数61
main:质数67
main:质数71
main:质数73
main:质数79
main:质数83
main:质数89
main:质数97
false
false
Process finished with exit code 0
3.线程的调度、优先级、分类和生命周期
3.1.线程的调度
- 调度策略：时间片轮转策略和抢占式策略
- Java的调度方法：
- 同优先级线程组成先进先出队列(先到先服务)，使用时间片轮转策略
- 对高优先级，使用优先调度的抢占式策略
3.2.线程的优先级
- 常量表示的优先级：MAX_PRIORITY:10、MIN _PRIORITY:1、NORM_PRIORITY:5
- setPriority(int newPriority) :改变线程的优先级
- getPriority() :返回线程优先值
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
3.3.线程的分类
- Java中的线程分为两类:一种是守护线程，一种是用户线程。
- 守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程，当前JVM将退出。
截图示例：在上述二.Thread类的相关方法的代码示例中加上如下代码段：
输出结果：把用户线程全部改为了守护线程，JVM中都是守护线程，当前JVM将退出。
3.4.线程的生命周期
Java线程它的一个完整的生命周期中通常要经历如下的五种状态:
- 新建: 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪:处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞:在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态
- 死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
4.线程的同步
4.1.同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
- 需要被同步的代码不能包含代码多了，也不能包含代码少了。
- 操作共享数据的代码，即为需要被同步的代码。
- 共享数据：多个线程共同操作的变量。
- 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
- 多个线程必须要共用同一把锁。
- 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
4.1.1同步代码块解决继承Thread类方式的线程安全问题
代码示例：
/**
* @Author: YuShiwen
* @Date: 2020/11/24 2:42 PM
* @Version: 1.0
*/
class Seat extends Thread{
private static int position = 100;
private static Object obj = new Object();
@Override
public void run() {
while(true){
synchronized (obj) {//或者synchronized (Seat.class)，只需要保证同步监视器相同即可
if (position > 0) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("从"+this.getName() + "得到座位，座位号为：" + position);
--position;
} else {
break;
}
}
}
}
}
public class SeatTest {
public static void main(String[] args) {
Seat seat0 = new Seat();
Seat seat1 = new Seat();
Seat seat2 = new Seat();
seat0.setName("渠道一");
seat1.setName("渠道二");
seat2.setName("渠道三");
seat0.start();
seat1.start();
seat2.start();
}
}
输出结果：
从渠道一得到座位，座位号为：100
从渠道一得到座位，座位号为：99
从渠道三得到座位，座位号为：98
从渠道三得到座位，座位号为：97
从渠道三得到座位，座位号为：96
从渠道三得到座位，座位号为：95
从渠道三得到座位，座位号为：94
从渠道三得到座位，座位号为：93
从渠道三得到座位，座位号为：92
从渠道三得到座位，座位号为：91
从渠道三得到座位，座位号为：90
从渠道三得到座位，座位号为：89
从渠道三得到座位，座位号为：88
从渠道三得到座位，座位号为：87
从渠道三得到座位，座位号为：86
从渠道三得到座位，座位号为：85
从渠道三得到座位，座位号为：84
从渠道三得到座位，座位号为：83
从渠道二得到座位，座位号为：82
从渠道二得到座位，座位号为：81
从渠道二得到座位，座位号为：80
从渠道二得到座位，座位号为：79
从渠道二得到座位，座位号为：78
从渠道二得到座位，座位号为：77
从渠道二得到座位，座位号为：76
从渠道二得到座位，座位号为：75
从渠道二得到座位，座位号为：74
从渠道二得到座位，座位号为：73
从渠道二得到座位，座位号为：72
从渠道二得到座位，座位号为：71
从渠道二得到座位，座位号为：70
从渠道二得到座位，座位号为：69
从渠道二得到座位，座位号为：68
从渠道二得到座位，座位号为：67
从渠道二得到座位，座位号为：66
从渠道二得到座位，座位号为：65
从渠道二得到座位，座位号为：64
从渠道二得到座位，座位号为：63
从渠道二得到座位，座位号为：62
从渠道三得到座位，座位号为：61
从渠道三得到座位，座位号为：60
从渠道三得到座位，座位号为：59
从渠道三得到座位，座位号为：58
从渠道三得到座位，座位号为：57
从渠道三得到座位，座位号为：56
从渠道三得到座位，座位号为：55
从渠道三得到座位，座位号为：54
从渠道三得到座位，座位号为：53
从渠道三得到座位，座位号为：52
从渠道三得到座位，座位号为：51
从渠道三得到座位，座位号为：50
从渠道三得到座位，座位号为：49
从渠道三得到座位，座位号为：48
从渠道三得到座位，座位号为：47
从渠道三得到座位，座位号为：46
从渠道三得到座位，座位号为：45
从渠道三得到座位，座位号为：44
从渠道三得到座位，座位号为：43
从渠道三得到座位，座位号为：42
从渠道三得到座位，座位号为：41
从渠道三得到座位，座位号为：40
从渠道三得到座位，座位号为：39
从渠道三得到座位，座位号为：38
从渠道三得到座位，座位号为：37
从渠道三得到座位，座位号为：36
从渠道三得到座位，座位号为：35
从渠道三得到座位，座位号为：34
从渠道三得到座位，座位号为：33
从渠道三得到座位，座位号为：32
从渠道三得到座位，座位号为：31
从渠道三得到座位，座位号为：30
从渠道一得到座位，座位号为：29
从渠道一得到座位，座位号为：28
从渠道一得到座位，座位号为：27
从渠道一得到座位，座位号为：26
从渠道一得到座位，座位号为：25
从渠道三得到座位，座位号为：24
从渠道三得到座位，座位号为：23
从渠道三得到座位，座位号为：22
从渠道三得到座位，座位号为：21
从渠道三得到座位，座位号为：20
从渠道三得到座位，座位号为：19
从渠道三得到座位，座位号为：18
从渠道三得到座位，座位号为：17
从渠道三得到座位，座位号为：16
从渠道三得到座位，座位号为：15
从渠道三得到座位，座位号为：14
从渠道三得到座位，座位号为：13
从渠道三得到座位，座位号为：12
从渠道三得到座位，座位号为：11
从渠道三得到座位，座位号为：10
从渠道三得到座位，座位号为：9
从渠道三得到座位，座位号为：8
从渠道二得到座位，座位号为：7
从渠道二得到座位，座位号为：6
从渠道二得到座位，座位号为：5
从渠道二得到座位，座位号为：4
从渠道二得到座位，座位号为：3
从渠道三得到座位，座位号为：2
从渠道三得到座位，座位号为：1
Process finished with exit code 0
4.1.2同步代码块解决实现Runnable接口方式的线程安全问题
class Seat1 implements Runnable{
private int position = 100;
@Override
public void run() {
while(true){
synchronized (this) {
if (position > 0) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
--position;
} else {
break;
}
}
}
}
}
public class SeatTest1 {
public static void main(String[] args) {
Seat1 seat1 = new Seat1();
Thread thread0 = new Thread(seat1);
Thread thread1 = new Thread(seat1);
Thread thread2 = new Thread(seat1);
thread0.setName("渠道一");
thread1.setName("渠道二");
thread2.setName("渠道三");
thread0.start();
thread1.start();
thread2.start();
}
}
输出结果：与上述结果差不多，这里为节省篇幅省略。
4.2.同步方法
synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如:
public synchronized void show (String name){ …
}
4.2.1使用同步方法处理继承Thread类方式中的线程安全问题
class Seat2 extends Thread{
private static int position = 100;
@Override
public void run() {
while (true){
getPosition();
}
}
//默认同步监视器：Seat2.class
private static synchronized void getPosition(){
if(position > 0){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
--position;
}
}
}
public class SeatTest2 {
public static void main(String[] args) {
Seat2 seat0 = new Seat2();
Seat2 seat1 = new Seat2();
Seat2 seat2 = new Seat2();
seat0.setName("渠道一");
seat1.setName("渠道二");
seat2.setName("渠道三");
seat0.start();
seat1.start();
seat2.start();
}
}
输出结果：与上述结果差不多，这里为节省篇幅省略。
4.2.2使用同步方法解决实现Runnable接口的线程安全问题
在这里插入代码片class Seat3 implements Runnable{
private int position = 100;
@Override
public void run() {
while (true){
getPosition();
}
}
//默认同步监视器：this
private synchronized void getPosition(){
if(position > 0){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("从"+Thread.currentThread().getName() + "得到座位，座位号为：" + position);
--position;
}
}
}
public class SeatTest3 {
public static void main(String[] args) {
Seat3 seat3 = new Seat3();
Thread thread0 = new Thread(seat3);
Thread thread1 = new Thread(seat3);
Thread thread2 = new Thread(seat3);
thread0.setName("渠道一");
thread1.setName("渠道二");
thread2.setName("渠道三");
thread0.start();
thread1.start();
thread2.start();
}
}
输出结果：与上述结果差不多，这里为节省篇幅省略。
4.3.Lock（锁）
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void method(){
lock.lock();
try{
//保证线程安全的代码;
} finally{
lock.unlock();
}
}
}
ps:如果同步代码有异常，要将unlock()写入finally语句块
代码示例：
class Seat implements Runnable{
private int position = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
//2.调用锁定方法lock()
lock.lock();
if(position >0){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("从"+Thread.currentThread().getName()+"得到座位，座位号为：" + position);
--position;
}else {
break;
}
}finally {
//3.调用解锁方法：unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Seat seat = new Seat();
Thread thread0 = new Thread(seat);
Thread thread1 = new Thread(seat);
Thread thread2 = new Thread(seat);
thread0.setName("渠道一");
thread1.setName("渠道二");
thread2.setName("渠道三");
thread0.start();
thread1.start();
thread2.start();
}
}
4.4.synchronized 与 Lock 的对比
- Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
4.5.释放锁和不会释放锁的操作
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作 - 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程 挂起，该线程不会释放锁(同步监视器)。
- 应尽量避免使用suspend()和resume()来控制线程
5.线程的通信
5.1wait() 、 notify() 和 notifyAll()
- wait() 与 notify() 和 notifyAll()
- wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll ():唤醒正在排队等待资源的所有线程结束等待.
- 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。
- 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁， 因此这三个方法只能在Object类中声明。
线程通信的应用：经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
class Clerk{
private int productCount = 0;
//生产产品
public synchronized void produceProduct() {
if(productCount < 20){
productCount++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
notify();
}else{
//等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if(productCount > 0){
System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
productCount--;
notify();
}else{
//等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{//生产者
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始生产产品.....");
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{//消费者
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始消费产品.....");
while(true){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c2.setName("消费者2");
p1.start();
c1.start();
c2.start();
}
}
5.2.CountDownLatch
- CountDownLatch是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下。
- CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在等待资源的线程就可以恢复执行任务。
- 它是通过一个计数器来实现的，计数器的初始值为线程的数量。
- 每当一个线程完成了自己的任务后，调用countDown方法，计数器的值就会减1。
- 当计数器值到达0时，它表示所有的线程已经释放完资源了，然后调用await的线程就可以恢复执行任务了。
如下demo：
public class UseCacheLineFill {
public volatile long A, B, C, D, E, F, G;
public volatile long x = 1L;
public volatile long a, b, c, d, e, f, g;
}
class MainDemo01 {
public static void main(String[] args) throws InterruptedException {
// 1.CountDownLatch是在java1.5被引入的，它是通过一个计数器来实现的，计数器的初始值为线程的数量。
// 2.每当一个线程完成了自己的任务后，调用countDown方法，计数器的值就会减1。
// 3.当计数器值到达0时，它表示所有的线程已经完成了任务，然后调用await的线程就可以恢复执行任务了。
// 计数器的初始值为1。
CountDownLatch countDownLatch = new CountDownLatch(2);
NoCacheLineFill[] arr = new NoCacheLineFill[2];
arr[0] = new NoCacheLineFill();
arr[1] = new NoCacheLineFill();
Thread threadA = new Thread(() -> {
for (long i = 0; i < 100_000_000L; i++) {
arr[0].x = i;
}
//计数器的值减1
countDownLatch.countDown();
}, "ThreadA");
Thread threadB = new Thread(() -> {
for (long i = 0; i < 100_000_000L; i++) {
arr[1].x = i;
}
//计数器的值减1
countDownLatch.countDown();
}, "ThreadB");
final long start = System.nanoTime();
threadA.start();
threadB.start();
//每调用一次countDown()方法计数器减一，当技术器等于0时await()方法后面的代码就可以执行了
countDownLatch.await();
final long end = System.nanoTime();
System.out.println("耗时：" + (end - start) / 1_000_000 + "毫秒");
}
}
CountDownLatch 常用方法如下：
CountDownLatch(int count); //构造方法，创建一个值为count 的计数器。
await();//阻塞当前线程，将当前线程加入阻塞队列。
await(long timeout, TimeUnit unit);//在timeout的时间之内阻塞当前线程,时间一过则当前线程可以执行，
countDown();//对计数器进行递减1操作，当计数器递减至0时，当前线程会去唤醒阻塞队列里的所有线程。
6.并发编程
并发编程三大特性：
原子性、可见性、有序性，下面分别进行讲解：
1.原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
比如i++，它分为三步：
- 从缓存读取 i的值到CPU通用寄存器中（CPU通用寄存器可以用来做加减乘除，具体可参见本人这篇博客：CPU和寄存器详解）
- 执行 i+ 1
- 将 i的新值写回
如果不保证原子性，会出现如下情况：
......
int i = 0;
i++;
......
刚开始，i初始化为0，假设有两个线程A，B；
当A正在执行：
- 上面我们提到过，i++不是原子操作，被拆分为了三步，
- 假如此时线程A执行到了第二步，读取到了i,i的值为初始化的值：0；然后把0+1=1，注意此时还没执行到第三步，还没有写回缓存中；
也就是说，此时缓存中i的值为0，A的寄存器中i的值为1； - 此时B线程开始执行，虽然A的寄存器中i的值为1，但是B寄存器它是从缓存中读取i的值，此时值是0，所以B线程取到i的值为0，B线程直接执行这三个步骤，0+1=1，执行完后写回缓存中；写回缓存i的值为1；
- 此时A线程执行到第三步，i的值为1，执行完，写回缓存，值也为1；
可以看到虽然我们做了两次++i操作，但是只进行了一次加1操作，这就是不能保证原子性带来的弊端。
2.可见性：变量修改，变量修改后，马上刷新到内存中，而其他线程能感知到变量的修改。
3.有序性：Java内存模型中的有序性可以总结为：如果在本线程内观察，所有操作都是有序的；如果在一
个线程中观察另一个线程，所有操作都是无序的。前半句是指“线程内表现为串行语义”，后半
句是指“指令重排序”现象和“工作内存主主内存同步延迟”现象。
两个关键字实现上述的特性：
1.synchronized: 具有原子性，有序性和可见性；
2.volatile：具有有序性和可见性
JMM不是真实存在的，只是一个抽象的概念。volatile也是借助CAS（Compare and Swap），即比较和置换来实现可见性的（实际上底层是MESI缓存一致性协议和总线嗅探机制），借助内存屏障得以实现有序性。
关于这个知识点的具体底层原理 笔者后续补上，还未完结，持续更新中哈…
未完待续，持续更新中......
更新于2022.2.28
Author：YuShiwen
于CSDN