并发编程（二）

1.线程的状态（生命周期）

上图就是线程生命周期的流程，共有六种状态，初始 运行 阻塞 等待 超时等待 终止。

下面为这些状态一 一解释下，

1. 初始(NEW)：新创建了一个线程对象，但还没有调用 start() 方法

2. 运行(RUNNABLE)：Java 线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程（比如 main 线程）调用了该对象的 start() 方法。 该状态的线程位于可运行线程池中，等待被线程调度选中，获取 CPU 的使用权，此时处于就绪状态（ready）。 就绪状态的线程在获得 CPU 时间片后变为运行中状态（running）

3. 阻塞(BLOCKED)：表示线程阻塞于锁

4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）

5. 超时等待(TIMED_WAITING)：该状态不同于 WAITING，它可以在指定的时间后自行返回

6. 终止(TERMINATED)：表示该线程已经执行完毕

以上几种状态我们可以用 jstack 去查看，之前jvm中有提及过。

2.小知识点：ConcurrentHashMap initTable 方法中的 yield ()

yield() 方法，表示让当前线程让出CPU的占有权，但是让出时间无法设置，且不会释放锁资源，且

再被选种不可控！

我们在阅读ConcurrentHashMap的源码时，会发现，在初始化这个方法中，有一个yield（）方法，这是为什么呢？

这是因为 ConcurrentHashMap 中可能被多个线程同时初始化 table，但是其实这个时候只允许一

个线程进行初始化操作，其他的线程就需要被阻塞或等待，但是初始化操作其实很快。为了避免阻

塞或者等待这些操作引发的上下文切换等开销，Doug Lea 大师让其他不执行初始化操作的线程干

脆执行 yield() 方法，以让出 CPU 执行权，让执行初始化操作的线程可以更快地执行完成

3.线程的优先级和调度

优先级：

在 Java 线程中，通过一个整型成员变量 priority 来控制优先级。优先级的范围从 1~10，在线程构建的时候可以通过 setPriority(int) 方法来修改优先级，默认优先级是 5。优先级高的线程分配时间片的数量要多于优先级低的线程。

设置线程优先级时，针对频繁阻塞（休眠或者 I/O 操作）的线程需要设置较高优先级，而偏重计算（需要较多 CPU 时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。但是需要注意的是，这种优先级也不是完全管用的，因为线程的调度是由OS操作的。

调度：Java中采用的是抢占式线程调度

线程调度是指系统为线程分配 CPU 使用权的过程，主要调度方式有两种：

1. 协同式线程调度(Cooperative Threads-Scheduling)： 在协同式线程调度中，每个线程自行决定何时释放 CPU 的使用权。当一个线程在执行时，其他线程需要等待该线程主动放弃 CPU 使用权，然后才能得到执行机会。这种调度方式要求每个线程都合作地主动释放 CPU，否则某个线程的不当行为可能导致其他线程无法执行，造成系统假死。

2. 抢占式线程调度(Preemptive Threads-Scheduling)： 在抢占式线程调度中，系统会根据线程的优先级和时间片等策略，强制剥夺正在执行的线程的 CPU 使用权，并将其分配给其他优先级更高的线程。这种调度方式允许操作系统对线程进行更精确的控制，能够更好地保障高优先级任务的及时执行。由于操作系统具有控制权，即使某个线程出现问题，也能够及时进行干预，从而保证系统的稳定性。

总体而言，抢占式线程调度相对更加灵活和可靠，因为系统具有更大的控制权，能够更好地应对线程的各种情况和问题。协同式线程调度则更依赖于线程的合作，如果一个线程无限期占用 CPU，可能会导致整个系统的响应性能下降。现代操作系统大多采用抢占式线程调度，以确保系统的稳定性和高效性。

4.线程的实现的方式（语言层面）

这一块比较抽象，总的概括来说有三种方式，内核线程实现 ，用户线程实现 ， 混合实现 。

什么是内核线程实现呢，其实就是由操作系统的内核去实现，直接与操作系统挂钩的，我们需要注

意的是Java中的多线程都是逻辑上的多线程，并不一定是真正的同时进行，所以这里说到的内核线

程去实现会被很多人觉得和CPU的多核挂钩，其实二者并无什么直接关系！这种内核线程的创建方

式和用户线程的比例是1:1（更推荐这种1: 1 模型 也有 1：N 的模型）；

什么是用户线程实现呢？用户线程实现是一种在用户空间（User Space）中实现线程调度和管理

的方式，与操作系统内核线程相对应。在用户线程实现中，线程的创建、销毁、调度以及同步等操

作都由用户空间的线程库（Thread Library）来完成，而不涉及操作系统内核。这使得线程的管理

和切换等操作可以在用户空间中快速执行，避免了涉及内核的开销；

混合实现 就是将上面的两种方式结合起来。

那么Java是怎么实现的呢？

在 Java 中，线程的创建和管理一直由 Java 虚拟机（JVM）负责，而不是直接由操作系统内核管理。因此，无论是 Java 1.2 之前还是之后，Java 的线程都是用户线程，存在于用户空间，由 JVM 的线程调度器在用户空间进行管理和调度。

Java 1.2 之后引入了 "Native Threads" 的概念，这与操作系统的内核线程有关。在 Java 1.2 之前，Java 的线程模型被称为 "Green Threads" 或 "Green Thread Model"，它是一种轻量级的用户线程模型。而在 Java 1.2 及以后的版本，Java 的线程模型与底层操作系统的线程模型进行绑定，被称为 "Native Threads" 或 "Native Thread Model"。

"Native Threads" 模型意味着 Java 的线程直接映射到操作系统内核线程，Java 线程成为操作系统内核线程的一部分。这样的设计可以更好地利用多核处理器的并发能力，提高多线程程序的性能和效率。

需要注意的是，尽管 Java 的线程模型在 Java 1.2 之后引入了 "Native Threads" 的概念，但是 Java 线程仍然属于用户线程，由 JVM 的线程调度器进行管理，而不是直接由操作系统内核管理。"Native Threads" 模型只是将 Java 线程与底层操作系统的线程模型绑定在一起，以实现更高效的并发执行。

Java中的现成虽然说是用户线程但是目前版本还是和内核直接挂钩的，这样在创建大量线程时会产生很大的内存消耗，默认情况下创建一个线程的大小为1M，所以当创建线程多时会十分占用资源，好在现在Quasar已经可以让我在代码中创建轻量级的线程[用户线程的一种替代方案]即纤程（Fiber）,在高IO的情况下我们使用Fiber时会更高效；下面是具体实现方法

1>引入包依赖

<dependency>
    <groupId>co.paralleluniverse</groupId>
    <artifactId>quasar-core</artifactId>
    <version>0.8.0</version>
</dependency>

 2>运行时配置 JVM配置 不然无法运行

-javaagent:D:\Maven\repository\co\paralleluniverse\quasar-core\0.8.0\quasar-core-0.8.0.jar

3>代码实现

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;

public class FiberExample {
    public static void main(String[] args) throws SuspendExecution, InterruptedException {
        // 创建并启动一个Fiber
        Fiber<Void> fiber = new Fiber<>(() -> {
            try {
                System.out.println("Fiber started.");
                Fiber.sleep(1000); // 模拟Fiber执行耗时操作
                System.out.println("Fiber finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        fiber.start();

        // 主线程继续执行其他任务
        System.out.println("Main thread continues.");
        Thread.sleep(500); // 模拟主线程执行耗时操作

        // 等待Fiber执行完成
        fiber.join();
        System.out.println("Main thread finished.");
    }
}

 守护线程

Daemon（守护）线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个 Java 虚拟机中不存在非 Daemon 线程的时候，Java 虚拟机将会退出。可以通过调用 Thread.setDaemon(true)将线程设置为 Daemon 线程。我们一般用不上，比如垃圾回收线程就是 Daemon 线程。

Daemon 线程被用作完成支持性工作，但是在 Java 虚拟机退出时 Daemon 线程中的 finally 块并不一定会执行。在构建 Daemon 线程时，不能依靠 finally 块中的内容来确保执行关闭或清理资源的逻辑。

join的使用

在 Java 中，join() 方法用于让一个线程等待另一个线程的完成。当一个线程调用另一个线程的 join() 方法时，它会阻塞自己，直到被调用的线程执行完成

public class JoinExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 1 - Count: " + i);
                try {
                    Thread.sleep(500); // 模拟线程执行的耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 2 - Count: " + i);
                try {
                    Thread.sleep(500); // 模拟线程执行的耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动线程1和线程2
        thread1.start();
        thread2.start();

        try {
            // 等待线程1执行完成
            thread1.join();

            // 等待线程2执行完成
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 所有线程执行完成后继续执行主线程
        System.out.println("All threads finished.");
    }
}

如上所示，只有当 thread1 和 thread2 都执行完毕后，主线程才会继续执行，并打印 "All threads finished."。

面试题：

现在有 T1、T2、T3 三个线程，你怎样保证 T2 在 T1 执行完后执行，T3 在 T2 执行完后执行？

答：用 Thread#join 方法即可，在 T3 中调用 T2.join，在 T2 中调用 T1.join。