并发编程（三）线程模型和通信

一、线程的调度机制

线程调度是指系统为线程分配CPU使用权的过程

主要两种：

• 协同式线程调度(Cooperative Threads-Scheduling)
• 抢占式线程调度(Preemptive Threads-Scheduling)

1.协同式线程调度的多线程系统

线程执行的时间由线程本身来控制，线程把自己的工作执行完之后，要主动通知系统切换到另外一个线程上。

使用协同式线程调度的最大好处是实现简单，由于线程要把自己的事情做完后才会通知系统进行线程切换，所以没有线程同步的问题，但是坏处也很明显，如果一个线程出了问题，则程序就会一直阻塞

2.抢占式线程调度的多线程系统

每个线程执行的时间以及是否切换都由系统决定。在这种情况下，线程的执行时间不可控，所以不会有「一个线程导致整个进程阻塞」的问题出现

在Java中，Thread.yield()可以让出CPU执行时间，但是对于获取执行时间，线程本身是没有办法的。对于获取CPU执行时间，线程唯一可以使用的手段是设置线程优先级，Java设置了10个级别的程序优先级，当两个线程同时处于Ready状态时，优先级越高的线程越容易被系统选择执行

二、Java线程模型

为什么Java线程调度是抢占式调度？这需要我们了解Java中线程的实现模式。

我们已经知道线程其实是操作系统层面的实体，Java 底层会调用 pthread_create 来创建线程，所以本质上 java 程序创建的线程，就是和操作系统线程是一样的，是 1 对 1 的线程模型

Java中的线程怎么和操作系统层面对应起来呢？

任何语言实现线程主要有三种方式：

1. 使用内核线程实现（1:1实现)，
2. 使用用户线程实现(1:N实现），
3. 使用用户线程加轻量级进程混合实现(N:M实现）。

内核线程实现

使用内核线程实现的方式也被称为1： 1实现。 内核线程（Kernel-Level Thread， KLT） 就是直接由操作系统内核（Kernel， 下称内核） 支持的线程， 这种线程由内核来完成线程切换， 内核通过操纵调度器（Scheduler） 对线程进行调度， 并负责将线程的任务映射到各个处理器上。

每个线程都成为一个独立的调度单元，即使其中某一个在系统调用中被阻塞了，也不会影响整个进程继续工作

Linux系统中线程实现方式

• LinuxThreads linux/glibc包在2.3.2之前只实现了LinuxThreads

虚拟线程 

在Java 21中，引入了虚拟线程

用户级线程的实现。虚拟线程是 Java 中的一种轻量级线程，它旨在解决传统线程模型中的一些限制，提供了更高效的并发处理能力，允许创建数千甚至数万个虚拟线程，而无需占用大量操作系统资源

public class VTDemo {

    public static void main(String[] args) throws InterruptedException {

        //平台线程
        Thread.ofPlatform().start(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        });

        //虚拟线程
        Thread vt = Thread.ofVirtual().start(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        });
        //等待虚拟线程打印完毕再退出主程序
        vt.join();

    }
}

输出：
Thread[#22,Thread-0,5,main]
VirtualThread[#23]/runnable@ForkJoinPool-1-worker-1

三、线程间的通信

1、管道输入输出流

Java 应用生成文件，然后需要将文件上传到云端

我们一般的做法是，文件-->本地磁盘-->云盘，但是通过Java中的管道输入输出流一步到位，则可以避免写入磁盘这一步。

Java中的管道输入/输出流主要包括了如下4种具体实现：

1、面向字节：PipedOutputStream、PipedInputStream

2、面向字符：PipedReader、PipedWriter

public class Piped {
    public static void main(String[] args) throws Exception {
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        // 将输出流和输入流进行连接，否则在使用时会抛出IOException
        out.connect(in);

        Thread printThread = new Thread(new Print(in), "PrintThread");

        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                out.write(receive);
            }
        } finally {
            out.close();
        }
    }

    static class Print implements Runnable {
        private PipedReader in;

        public Print(PipedReader in) {
            this.in = in;
        }

        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = in.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException ex) {
            }
        }
    }
}

2、volatile（最轻量的通信/同步机制）

volatile 关键字用于保证变量的可见性，即当一个变量被声明为 volatile 时，它会保证对该变量的写操作会立即刷新到主内存中，而读操作会从主内存中读取最新的值

public class VolatileDemo {

    private static volatile  boolean stop = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程t1开始执行");
                int i=0;
                while (!stop){
                    i++;
                }
                System.out.println("跳出循环");
            }
        },"t1");
        t1.start();

        Thread.sleep(1000);
        stop = true;
        System.out.println("主线程修改stop=true");

    }
}

（1）不加volatile时，子线程无法感知主线程修改了stop的值，从而不会退出循环

输出：
线程t1开始执行
主线程修改stop=true

（2）加volatile时，子线程可以感知主线程修改了ready的值，迅速退出循环。

输出：
线程t1开始执行
主线程修改stop=true
跳出循环

Java线程之间的通信由Java内存模型（Java Memory Model，简称JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。根据JMM的规定，线程对共享变量的所有操作都必须在自己的本地内存中进行，不能直接从主内存中读取。JMM通过控制主内存与每个线程的本地内存之间的交互，来为Java程序提供内存可见性的保证。

线程B-->共享变量的副本-->主内存共享变量-->共享变量的副本-->线程A

3、Thread.join

等待通知机制

join可以理解成是线程合并，当在一个线程调用另一个线程的join方法时，当前线程阻塞等待被调用join方法的线程执行完毕才能继续执行，所以join的好处能够保证线程的执行顺序，但是如果调用线程的join方法其实已经失去了并行的意义，虽然存在多个线程，但是本质上还是串行的，最后join的实现其实是基于等待通知机制的。 

4、等待/通知机制

线程之间相互配合完成某项工作，比如：一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。

前者是生产者，后者就是消费者，简单的办法是让消费者线程不断地循环检查变量是否符合预期在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。却存在如下问题：

synchronized(对象) {
    while (条件不满足) {
        对象.wait();
    }
    对应的逻辑;
}

synchronized(对象) {
    改变条件
    对象.notifyAll();
}

LockSupport是JDK中用来实现线程阻塞和唤醒的工具，线程调用park则等待“许可”，调用unpark则为指定线程提供“许可”。类似于发放许可证

LockSupport很类似于二元信号量(只有1个许可证可供使用)，如果这个许可还没有被占用，当前线程获取许可并继续执行；

如果许可已经被占用，当前线程阻塞，等待获取许可。

使用它可以在任何场合使线程阻塞，可以指定任何线程进行唤醒，并且不用担心阻塞和唤醒操作的顺序，但要注意连续多次唤醒的效果和一次唤醒是一样的

Java锁和同步器框架的核心AQS:AbstractQueuedSynchronizer，就是通过调用LockSupport.park()和 LockSupport.unpark()实现线程的阻塞和唤醒的

public class LockSupportDemo {

    public static void main(String[] args) throws InterruptedException {

        Thread parkThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("ParkThread开始执行");
                // 当没有『许可』时，当前线程暂停运行；有『许可』时，用掉这个『许可』，当前线程恢复运行
                LockSupport.park();
                System.out.println("ParkThread执行完成");
            }
        });
        parkThread.start();

        Thread.sleep(1000);

        System.out.println("唤醒parkThread");
        // 给线程 parkThread 发放『许可』（多次连续调用 unpark 只会发放一个『许可』）
        LockSupport.unpark(parkThread);
    }

}