「课件」原创 => Java's 多线程【转载请标明出处】

第一章·何为多线程？

多线程是一种并发执行的编程方式，它允许程序同时执行多个线程（线程是执行流的最小单位），从而提高程序的性能和效率。每个线程都是独立的执行序列，它们共享相同的进程资源，如内存空间，但拥有自己的寄存器和栈。多线程可以在单个程序中执行多个任务，使得程序能够更充分地利用多核处理器或同时处理多个任务，从而加速程序的运行。

进程：是程序执行的一个实例。它拥有自己的地址空间、内存、文件描述符和其他系统资源。每个进程都是独立的，彼此之间不会直接共享内存。

线程的话，其实就是在同一个进程里面创造开启的，它会共享相同的地址空间和其它资源，但是每个线程又都有自己的执行任务（这也是多线程的存在意义）

线程切换的开销相对较小，因为线程共享相同的地址空间，切换主要涉及到寄存器和栈的切换。

缺点：线程之间虽然可以更方便地共享数据，但也需要注意同步和互斥问题。因为共享，所以当然会有冲突。一句话让你理解！

多线程的应用场景：适用于需要共享数据、共享资源、并发执行的任务，尤其在需要快速响应用户输入的应用程序中！

然后给大家再一嘴有的没的 协程：也是用于实现并发编程的方式，但它在很多情况下，都认为是比多线程更好的存在！

协程是轻量级的执行单位，相较于线程更加节省资源。
由于协程的轻量级特性和更小的切换开销，通常能够在相同硬件上执行更多的并发任务，从而提供更好的性能。
最重要的一点是：协程通常使用异步编程模型，通过事件循环等机制来处理并发。由于协程的切换是显式的，可以避免一些多线程中常见的同步问题，如竞态条件（Race Condition）和死锁（Deadlock）。
协程的本质是单线程的快速切换！所以管理起来真的简单多了 ~
在代码角度上：由于协程通常使用顺序化的代码结构，相较于多线程，代码可能更易于理解和调试。

举例子说明吧（毕竟很多人都没有操作系统的知识前提）

你打开一个应用程序，比如说 QQ、微信、LOL 对吧，它们都会被加载到内存中，都有着系统给它们分配好的内存空间。而实际上，我们的这些应用都是很复杂的，并且要求效率较高的，毕竟要给用户友好的体验嘛。如果是单个线程的话，也就是我们只有要给 main 主方法，然后运行之后，只开启了一个主线程，去执行 main 方法里面的逐行代码。这样就显得效率很低。当你的程序要去做的事情，我们称为 "任务"，变多了之后，我们其实是会发现可以并发分工的现象的！

举个例子：比如你输出一个提示信息，与你现在去读取数据库的数据，完全可以并发分工去做的，它们之间没有太多的纠缠关系。但是如果你只有一个线程的话，那么就只能等一步一步的代码完成一个一个的任务，这。。。是不是有点儿感觉无语 ~

为了解决这样的问题，操作系统提供了多线程的概念，即一个进程，可以开辟多个线程去并发的执行各自的任务。提高效率和用户体验。

并发:并发是指两个或多个事件在同一时间间隔发生。
并行:并行是指两个或者多个事件在同一时刻发生。

多个线程或进程”同时”运行只是感官上的一种表现。事实上进程和线程是并发运行的，OS的线程调度机制将时间划分为很多时间片段（时间片），尽可能均匀分配给正在运行的程序，获取CPU时间片的线程或进程得以被执行，其他则等待。而CPU则在这些进程或线程上来回切换运行。微观上所有进程和线程是走走停停的，宏观上都在运行，这种都运行的现象叫并发，但是不是绝对意义上的同时发生。

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

Java中的并行执行可以使用Java的并行库（如ThreadPoolExecutor类）来实现，也可以利用Java arallel Streams）来进行处理。

需要注意的是，并行执行不一定会比并发执行更快，因为并行是多个独立的CPU核心的，并且任务之间存在一定的通信和同步开销。而并发执行可以在单核处理器上进行，任务开销相对较小。另外，并行执行对任务的分解和处理有一定的限制的，某些依赖于前一步骤结果的任务，可能就无法并行执行了。因此，在实际应用中需要根据具体情况来选择并发还是并行。

Java 创建线程的方式：

继承 Thread 类
实现 Runnable 接口
实现 Callable 接口
线程池

第二章· Thread 类

当进程创建的时候，会创建一个主线程(main方法)，还有一个就是 JVM 特有的 GC（垃圾回收）线程。

main函数叫 “用户线程/主线程” 是自己写的！

GC 线程是JVM给我们的，也被称为 “守护线程”！

其它的线程，我们可以通过继承 Thread，重写里面的 run 方法来编写线程执行体（也就是待执行的任务），再创建线程对象，调用 start() 方法启动线程！

package www.muquanyu.lesson01;

public class ThreadDemo extends Thread {

    @Override
    public void run()
    {
         System.out.println("我是子线程！");
    }

    //主线程
    public static void main(String[] args) {
        //开启子线程
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
        //主线程的执行代码
        for(int i = 0;i<20;++i)
        {
            System.out.println("我是主线程");
        }
    }
}

第三章·线程六大状态

NEW：new 一个 Thread 对象的时候，线程就被创建出来了！然后没有调用 start() 之前的状态。
RUNNABLE：运行状态，当调用 start 后会先进

就绪状态，即系统不会立即开启线程！而是通过 CPU 的调度器让其进行随机的开启（当然不是真正意义上的随机，CPU 是根据自身的最优策略选择的！）。观测的时候，就绪也被归在 NEW 状态！
BLOCKED：阻塞状态，当访问已被锁的对象，这时候就会进入阻塞了！
WAITING：等待状态，执行wait，join，park等方法时候，线程会进入等待状态。进行特定的操作才会进入RUNNABLE。
TIMED_WAITING：有时间的等待，除了特定的操作解除外，还可以等时间结束解除。
TERMINATED：结束状态。正常运行完或者终止都会进入这个状态。

3.1 线程休眠

sleep（时间）指定当前线程阻塞的毫秒数
sleep 存在异常 InrerruptedException
sleep 时间达到后，才会让线程进入就绪状态。
sleep 可以模拟网络延时，倒计时等。而且比时钟好用多了。它可以用在各个代码段中间，直接调用 sleep 进行代码段的延迟。这么简便的代码。时钟是完全不能办到的！！！

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("我是主线程，我即将通过 sleep 进入阻塞状态");
        Thread.sleep(1000);
        System.out.println("一秒过去了");
        Thread.sleep(1000);
        System.out.println("第二秒过去了");

    }
}

可以提前记住一个概念：每一个对象都有一个锁，而 sleep 是根本不会释放锁的！！！

目前 JDK 其实是比较推荐让线程自己停止下来的！已经不推荐使用 stop()、destroy() 方法了，这个一定要知道。

建议使用一个标志位进行终止变量。当 flag == false,则终止线程运行。

public class Demo01 {
    private static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while(flag){
                System.out.println("子线程正在执行！");
            }
            System.out.println("子线程停止执行！");
        });
        thread.start();
        System.out.println("我是主线程，我即将通过 sleep 进入阻塞状态");
        Thread.sleep(1000);
        System.out.println("一秒过去了");
        Thread.sleep(1000);
        System.out.println("第二秒过去了");
        for(int i = 0; i < 10000; ++i){
            if(i == 3000) Demo01.stop();
            
        }
    }

    public static void stop(){
        flag = false;
    }
}

我们知道线程一旦被开启，最终都会自己走向死亡状态。 而这个死亡状态是在运行状态之后进入的！那么运行状态在做什么呢？就是在执行代码！！！换句话说，事务的代码执行完毕后，线程就会自己进入死亡状态！不需要我们强制性的关闭。这也是为什么 Java 不推荐使用 stop()方法和 destroy() 方法。

思考：如果说线程之间是并发的，那么是否可能因为时间切换频率过快，导致判断没反应过来，多输出一条信息呢？

答：这是太有可能了，如果你能有这样的想法，其实就代表你对线程有了一定的理解！如果不信的话，其实可以自己去试试。

【作业：尝试是否会多输出一条信息？自己想一想用什么方式可以看的清晰】

3.1.1 定时器（更加符合面向对象）

定时器的发明，是为了写代码的时候，更加符合面向对象的思想。实际上，定时器能干的活儿，Thread.sleep() 都完全 Ok 的 ~

Timer 定时器，内部维护了一个 TaskQueue 任务队列，然后它也给这个队列开了个 TimerThread 线程，用来时刻监视这个队列里面是否还有待执行的任务了？如果没有待执行的任务，则是会处于休眠状态 TimerThread 线程，因为它害怕还会有新的任务加进队列。除非你用 cancel() 否则不会停止 TimerThread 线程！

import java.util.Timer;
import java.util.TimerTask;

public class 定时器 {
    static int num = 0;
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                if(num++ == 10) timer.cancel(); // 将维护队列的线程干掉
                System.out.println(Thread.currentThread().getName());
            }
        },0,1000);
    }
}

timer.schedule(TimerTask task, long delay, long period)

task：线程执行的任务

delay：线程执行前的 sleep() 延迟

period：重复性（循环）执行 task 任务的间隔时间

3.2 线程中断

其实就是 interrupt() 方法的调用，它会给线程打个中断标记，让线程响应这个标记，然后去进行中断的相应处理。它跟 stop() 是不一样的，stop 是强制性的停止线程，可能导致资源不完全释放。如果说，让我在这俩个方法中选择的话，肯定选 interrupt()，但实际上，我们不如自己去声明一个 flag 变量打标记。

interrupt 的本质：其实就是咱们上面写的 建议使用一个标志位进行终止变量。当 flag == false,则终止线程运行。 是的，你没看错，它的本质就是这个。我们刚才已经写出来了 ~ 就是 Thread 里面也有一个类似于 flag 的标记，然后我们通过

Thread.currentThread().isInterrupted() 这样的方法就可以查看这个标记是否为 true，如果为 true 那么就可以让线程自然结束了，这个自然结束的操作，其实还是你自己手动写的。

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while(true){
                if(Thread.currentThread().isInterrupted())
                    break;
                System.out.println("子线程正在执行！");
            }
            System.out.println("子线程停止执行！");
        });
        thread.start();
        System.out.println("我是主线程，我即将通过 sleep 进入阻塞状态");
        Thread.sleep(1000);
        System.out.println("一秒过去了");
        Thread.sleep(1000);
        System.out.println("第二秒过去了");
        for(int i = 0; i < 10000; ++i){
            if(i == 3000) thread.interrupt(); // 打标记
            
        }
    }
}

3.2.1 中断复位

听着听高大上是吧，实际上就是将标记撤销了，说白了就是类似于 flag = false 也就是随后再有代码片段判断是否有中断标记的话，都会返回 false，也就是没有。

复位的方法：Thread.interrupted();

3.3 线程暂停

Thread.currentThread().suspend()：暂停线程

Thread.resume：恢复线程（从 suspend() 恢复）

3.3.1 wait、notify、notifyall

当谈到 wait()、notify() 和 notifyAll() 时，老Java程序员，直接就知道了，这仨不就是在Java多线程编程中用于实现线程间协作和同步机制的嘛。下面我会用简单的语言为你解释这三个方法：

首先，这三个方法是每个对象都会有的！因为所有的对象的祖宗类是 Object，而 Object 本身就有这三个方法！
wait() 方法：

当一个线程调用某个对象的 wait() 方法时，它就进入了等待（阻塞）状态，并释放了持有的锁。（与 sleep 不一样是吧 ~ sleep 可不会给你释放锁）这个线程会等待其他线程调用相同对象上的 notify() 或 notifyAll() 方法来唤醒它。通常，wait() 方法被用于线程等待某个条件的满足。

notify() 方法：

当一个线程调用某个对象的 notify() 方法时，它会唤醒等待在这个对象上的一个（任意一个）被 wait() 方法阻塞的线程。注意，被唤醒的线程并不会立刻执行，而是等待当前线程释放锁才能继续执行。通常，notify() 方法被用于通知等待线程某个条件已经满足。

notifyAll() 方法：

与 notify() 不同，notifyAll() 方法会唤醒在某个对象上所有被 wait() 方法阻塞的线程。这样，所有等待的线程都有机会竞争获取锁并继续执行。通常，notifyAll() 方法在不同线程之间共享状态改变时使用，以确保所有等待的线程都能够得到通知。

此外，Java 中的 wait()、notify() 和 notifyAll() 必须在同步块内部调用，因为它们依赖于对象的监视器锁。

3.4 线程的优先级（重点）

首先 Java 采用的是抢占式调度方式！即 Java 提供一个 人为模拟的 线程调度器来监控程序中启动后进入就绪装态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。一般情况下，任务较重的线程会设置较高的优先级。

**PS：虽然 Java 模拟了一个类似于 CPU 调度器的东西，但实际上最后还得是看 CPU 怎么调度舒服怎么来。只不过事先的人为干涉，可以起到大概率的作用！ **

优先级数字范围：【1 ~ 10】
Thread.currentThread.getPriority()：获取到线程的优先级
线程对象.setPriority(数字)：设置线程的优先级
Thread.MAX_PRIORITY 最高优先级
Thread.MIN_PRIORITY 最低优先级
Thread.NOM_PRIORITY 常规优先级
线程对象.setPriority(Thread.MAX_PRIORITY)

3.4.1 设置优先级的问题

问题：由于它们是在主线程里启动子线程的，所以运行代码的顺次步骤，也可能会对CPU调度的顺序进行影响。（也就是说即使在没有进行优先级的设置情况下，谁的 .start()代码写在前面，谁就可能先被调度。而且这种问题会影响到设置优先级的概率！！！）

即，优先级只是人为的模拟，进行的大概率调节！

为了避免这种情况，我们一般要保证所有线程的启动代码，都要根据设置的优先级顺次的堆积在一起来写！

package www.muquanyu.lesson03;

//测试线程的优先级
public class PriorityDemo {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());

        MyPriorityDemo MyPriority = new MyPriorityDemo();

        Thread t1 = new Thread(MyPriority);
        Thread t2 = new Thread(MyPriority);
        Thread t3 = new Thread(MyPriority);
        Thread t4 = new Thread(MyPriority);
        Thread t5 = new Thread(MyPriority);
        Thread t6 = new Thread(MyPriority);

        //设置优先级（正确的设置优先级方式）
        t2.setPriority(1);
        t3.setPriority(4);
        t4.setPriority(Thread.MAX_PRIORITY);
        t5.setPriority(6);
        t6.setPriority(8);
//正确的 线程方式（如果你设置了优先级，那么启动的顺序就按照 优先级的顺序来写！）
        t4.start();
        t6.start();
        t5.start();
        t1.start();
        t3.start();
        t2.start();
    }
}

class MyPriorityDemo implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());

    }
}

上述这种方式，是在设置优先级之后，最正确的写法！！但是也保证不了 CPU 调度的情况一定按照优先级来走。

3.5 线程状态查询

线程对象.getState()：就可以获取这个线程当前的状态

3.6 线程礼让与合并线程

3.6.1 线程礼让

线程礼让：让当前正在执行的线程暂停，但不是阻塞！
线程礼让不会让程序阻塞，而是直接转为 就绪状态。
本质上，就是让 CPU 重新对该线程进行调度，所以我们说礼让还不一定成功呢 ~ 这得看 CPU 的心情！

Thread.yield()：它的意思就是，让你直接回到就绪状态。然后再经过 CPU 调度。这个时候，如果还有线程比你慢，那就说明它命不好。可能在你回到就绪状态的时候，正好 CPU 把你排在了它的前面。（但这也是针对于还没有进入运行状态的线程。）

情景解释：小明已经跑出去十米了，但是小红刚来到起跑线位置，就跟小明说，你回来一趟，咋俩竞赛一次。看看谁跑的快！

3.6.2 合并线程

合并线程（插队线程）：有那么一点儿插队的意思，比如说一个线程正在执行代码呢，然后另一个线程想要在它执行的过程中，跑起来，那么直接在任务代码里面写上 线程对象.join() 这个线程就可以跑起来了。

只不过合并过来的线程，优先级比较高，而且还会阻塞之前的线程！

应用场景：比较适合特判任务执行时，遇到的特殊情况，需要执行的特殊任务处理。这个任务优先级必须得高，必须优先处理才行！

package www.muquanyu.lesson03;

public class JoinDemo {

    public static JoinThread joinThread = new JoinThread();
    public static Thread VIP = new Thread(joinThread,"VIP线程");

    public static void main(String[] args) {

        MyThread myThread = new MyThread();
        Thread A = new Thread(myThread,"线程A");

        A.start();


    }

    public static class MyThread implements Runnable{
        @Override
        public void run(){
            System.out.println("开始排队");
            try {
                VIP.start();
                VIP.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我草，才轮到我？");
        }
    }

    public static class JoinThread implements Runnable{
        @Override
        public void run() {
            System.out.println("哈哈，VIP进行插队！");
            for(int i = 0;i<3;++i)
            {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

第四章·Runnable&&初见并发问题

其实 Thread 这个类就是 Runnable 接口的实现，所以我们建议直接用 Runnable 接口，而不是去用二次封装的 Thread 是有道理的。

需要注意的是，我们虽然可以实现 Runnable 接口，实现里面的 run() 方法。但仍然需要 new Thread() 创建一个线程对象，把其实现 Runnable 接口的对象给包裹住！然后通过 Thread 对象.start() 去启动这个线程！

package www.muquanyu.lesson01;

// 实现 Runnable 接口
public class RunnableDemo implements Runnable {

    @Override
    public void run() {
        for(int i = 0;i<200;++i)
        {
            System.out.println(Thread.currentThread().getName() + "=>" + i);
        }
    }

    public static void main(String[] args) {

//需要 建立一个 Thread 对象
        // 包裹住 这个 实现 Runnable 的类
        Thread thread = new Thread(new RunnableDemo());
        thread.start();
        // 我们可以 让不同的线程 执行同样的 任务
        Thread t2 = new Thread(new RunnableDemo());

        for(int i = 0;i<200;++i)
        {
            System.out.println(i);
        
    }

}

继承Thread 与实现 Runnable 接口 => 两者的区别

继承 Thrad 类

子类继承 Thread 类具备多线程能力

启动线程：子类对象.start()

不建议使用：我们必须避免OOP 单继承的局限性（要是想继承一些其它的强大的类，那就是个问题。。）

实现 Runnable 接口

实现接口 Runnable 具有多线程能力

启动线程：传入目标对象 + Thread 对象.start()

推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

比如说三个线程同时跑一个事务！你要是继承 Thread 的那种方式，可是无法实现的。只有实现 Runnable 接口才可以。

4.1 使用 lambda 表达式

我们追随 Thread 类的源代码，会发现 =>

它说我们要传递进去一个实现 Runnable 运行的这个接口的对象，这个对象里面确实只有一个方法 run() 是用来存放我们想要执行任务的内容代码的！函数式接口，可以lambda表达式

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            System.out.println("Hello 我是线程 A");
        });
        thread.start();

        System.out.println("我是主线程");
    }
}

你会发现主线程这条输出在上面，而线程 A 在下面。其实这里就已经有点儿多线程那味了 ~ 就是根本不是一个线程，一条一条代码执行的。它现在是 并发的。快速的轮换平均的去执行这两个线程的任务。

可能我们来两个循环，会更加明显，是吧 ~

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            for(int i = 0; i < 100; ++i){
                System.out.println("我是子线程 =>" + i);
            }
        });
        thread.start();

        System.out.println("我是主线程");
        for(int i = 0; i < 100; ++i){
            System.out.println("我是主线程 => " + i);
        }
    }
}

Thread对象.start()：启动线程

4.2 初见并发问题（竞态条件）

我们都知道 Java 的线程默认是并发的，而并发是存在一些问题的！最常见的并发问题就是竞态条件：是指在多线程或多进程的程序中，由于执行顺序的不确定性而导致程序的最终状态依赖于线程或进程的执行顺序。具体而言，竞态条件发生在多个线程或进程同时访问共享资源，并且其中一个线程或进程执行的结果会影响其他线程或进程的行为。

竞态条件通常是由于缺乏适当的同步机制，导致并发执行的不确定性而引起的。例如，在没有锁或其他同步手段的情况下，多个线程可能同时访问和修改共享的变量，导致意外的行为。

public class 竞态条件 {
    // 共享计数器
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程，分别定义线程的执行逻辑
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                // 读取计数器的值
                int value = counter;
                // 执行递增操作
                value = value + 1;
                // 将结果写回计数器
                counter = value;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                // 读取计数器的值
                int value = counter;
                // 执行递增操作
                value = value + 1;
                // 将结果写回计数器
                counter = value;
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        thread1.join();
        thread2.join();

        // 显示计数器的最终值
        System.out.println("最终计数器值: " + counter);
    }
}

你看看，这是个啥 ~ 10000 + 10000 = 20000，它这 14332 属实逆天 ~

两个线程在同时操作共同变量时，进行递增。可能会取到同样的值，然后同样 + 1 再次写回到主存中，那么可能这个值就只是 + 1 的结果。而非 + 2 的结果。

总结：当多个线程对象，操作同一个资源的情况下，线程是不安全的。会造成竞态条件，导致数据紊乱！

4.2.1 ThreadLocal

我们在解除了上面的并发问题之后，有的小伙伴就灵机一动。欸？每个线程难道非要使用共享资源嘛？可不可以有自己的独立的资源，只能我自己用？不能其他人用？万一有这样的需求呢？至此，Java 提供了类，即线程本地的意思，是说我们当前这个线程本地里面有自己的资源，而其它线程里面本地也有自己的资源。但是，ThreadLocal 只允许每个线程只有一个自己的本地资源！

public class 线程本地资源 {
    public static void main(String[] args) throws InterruptedException {
        ThreadLocal<String> local = new ThreadLocal<>();
        Thread threadB = new Thread(() -> {
            local.set("哇哈哈");
            System.out.println(local.get());
        });
        Thread threadA = new Thread(() -> {
            local.set("fcker"); // 将这个字符串交给 local，然后 local 会根据你这个 线程 打个标记，代表你这个线程 的local 资源就是 这个字符串！
            System.out.println(local.get());
            try {
                threadB.start();
                threadB.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        threadA.start();
    }
}

你会发现，各自 Local 资源都是各自的！哈哈哈 ~ 有点儿绕。。

4.3 经典问题·龟兔赛跑

package www.muquanyu.lesson01;

//模拟龟兔赛跑
public class Race implements Runnable {
    //只能 有一个 胜利者，所以是 静态的
    private static String winner;
    @Override
    public void run() {

        for(int i = 0;i <= 100;++i)
        {
            if(Thread.currentThread().getName().equals("兔子") && i%10==0)
            {
                try{
                    Thread.sleep(1);
                }catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            boolean flag = gameOver(i);
            if(flag)
            {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-->跑了"+i+"米！");
        }
    }

    private boolean gameOvera(int i) {
        return false;
    }

    //判断是否完成比赛
    private boolean gameOver(int steps)
    {
        if(winner != null)
        {
            return true;
        }
        if(steps == 100)
        {
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+ winner);
            return true;
        }
        return false;
    }


    public static void main(String[] args) {
        Race race = new Race();

        Thread 兔子 = new Thread(race, "兔子");
        Thread 乌龟 = new Thread(race, "乌龟");
        兔子.start();
        乌龟.start();
    }
}

第五章·Callable 接口

这个接口非常的严谨，所以很复杂。多了个开启服务和关闭服务。并且还得把线程必须放到线程池子里面去！

步骤：

实现 Callable 接口，需要有返回值类型
重写里面的 call 方法，还需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(线程的数目);//用 Executors 创建一个新的线程池
提交执行：Future result1 =ser.submit(t1);
获取结果：boolean r1 = result1.get();
关闭服务：ser.shutdownNow()；

这个，我们暂时也是只作为了解呀！其实常用的最多的，就是继承 Thread 和实现 Runnable 接口。

我个人比较喜欢用 Runnable 接口那种的 lambda 表达式

第六章·守护线程和线程同步

6.1 守护(daemon)线程

线程分为 用户线程 和 守护线程
JVM 虚拟机必须确保用户线程执行完毕
JVM 不用等待守护线程执行完毕 < 守护线程跟主线程和用户线程不是一路子的。 >
如：后台记录操作日志，监控内存，垃圾回收等等。都是守护线程！

什么叫做 JVM 虚拟机不等待守护线程？？

答：就是说守护线程的关闭和停止，不是由 JVM 虚拟机决定的。而是由 操作系统决定的。当程序真正的被停止后。或者说当所有的用户线程和主线程停止后。守护线程才会被系统关闭和停止，而并非 JVM 虚拟机。JVM 虚拟机只会关闭和停止用户线程，当用户线程执行的事务完毕后（代码执行完了后），JVM 就会帮这些用户线程进行自动的关闭和停止！而守护线程是先看一看，整个程序是否还存在用户线程或主线程是否还有存在的意义。而决定自己到底是否还要继续守护下去。

我们可以说，守护线程是后台线程，它的优先级较低！整个程序都不需要等待这个线程执行完成。这样做的意义就是当子线程无限循环时，出现退不出程序的情况时候。为了避免孤儿线程。此时你把这个线程设定为守护线程即可，我们就不需要等待这个线程执行完成了！所以，如果是我们普通用户使用守护线程，一般都是一些需要进行一直死循环监视的线程，尽量的去设为守护线程！！！

public class 守护线程 {
    public static int num = 10;
    public static boolean flag;
    public static void main(String[] args) {
        Thread monitor = new Thread(() -> {
            while(true){
                if(num == 0){
                    System.out.println("检测到 num = 0");
                    flag = true;
                }
            }
        });
        Thread temp = new Thread(() -> {
            while(true){
                System.out.println("子线程在执行！");
                num--;
                if(flag){
                    break;
                }
            }
        });
        monitor.setDaemon(true);
        temp.start();
        monitor.start();

//        while (monitor.getState() != Thread.State.TERMINATED){
//            System.out.println("monitor -----> " + monitor.getState());
//        }
        System.out.println("monitor -----> " + monitor.getState());

    }
}

注意：在守护线程的任务中，产生的新线程默认也是守护的！

6.2 线程同步

线程同步是解决线程并发问题的最常见方案！

现实生活中，我们其实就会遇到 “同一个资源，多个人都想使用” 的问题，比如说食堂排队在打饭，每个人都想要吃饭，但是必须遵守基本的道德准则和规范规则！！ 否则你一闹事可能会导致大家都吃不到饭了。
处理多线程问题的时候，多个线程访问同一个对象，并且某些线程还想去修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制。多个需要同时访问此对象的线程需要进入这个对象的 “等待池” 形成队列，等待前面的线程使用完毕，下一个线程再去使用！（这样就有规则和规范，并且效率也不会因此降低多少！！！）

那么后面排队的人，也就是在等待池里面的人，怎么会知道前面的那个线程正在处理资源呢？这就涉及到锁的概念了！

6.2.1 线程锁的理解

线程锁（Thread Lock）是一种同步机制，用于控制多个线程对共享资源的访问。在并发编程中，多个线程同时访问共享数据可能导致不确定的结果或数据损坏。线程锁通过确保在任何时刻只有一个线程可以访问共享资源，从而防止竞态条件（Race Condition）的发生。

举个场景：你去上厕所抢坑位，如果里面有人，并且上了锁，那你就没办法了，只能等人家上完 ~ 当然了~ 如果他没上锁，嘿嘿~ 所以，锁挺重要的。

解决竞态条件的方案：确保在同一时刻只有一个线程能够执行被保护的代码段，从而避免！ 那妥了，我直接咔吧，给共享的资源锁上。我先处理，然后你们等会儿，等我处理完了，你们再去处理。呦西 ~

常见的线程锁又有：互斥锁（Mutex）和信号量（Semaphore）操作系统的知识

互斥锁用于保护共享资源，确保同一时刻只有一个线程可以访问（也就是操作的原子性）
信号量除了可以用于同步外，还可以用于控制对共享资源的访问数量。

第七章·synchronized 与锁

7.0 Java 中的锁

在 Java 中，每个对象其实都有其相关联的监视器锁（也称为内置锁或对象锁，其实本质就是互斥锁！）

这个锁是由Java虚拟机（JVM）自动提供的，用于实现对象级别的同步。

Java 提供了 synchronized 关键字的两种方式：

synchronized 方法
synchronized 代码块

synchronized 这个玩意，实际上就是在操作对象的监视器锁，不同对象的监视器锁是独立的！因此它们之间互不影响。当一个线程碰到了一个使用了 synchronized 关键字修饰的方法或代码块时，它就必须先要拿到对象的 监视器锁，其它的线程此时就处于阻塞状态 等待着该线程把 释放锁。如果你尝试获取到这个锁，那肯定会阻塞！因为这个锁已经被占用了。

线程锁可能会面临的问题：

在多个线程竞争下，加锁和释放锁，会导致比较频繁的切换和调度延时，这会引起性能问题。
如果一个优先级高的线程去等待一个优先级低的线程去释放锁，那么这就演化成了优先级的倒置问题！是性能的大问题。

这就说明了 “鱼和熊掌” 二者不能兼得的道理。你想要性能那么数据在大概率情况下，是避免不了危险的。你想要安全，那么性能在大概率情况下也是避免不了变慢的。

7.1 synchronized 同步方法

为什么只有方法和方法快呢？

答：因为面向对象推荐，对象的属性最好用 private 封装，然后用公开的方法去对其进行操作。所以我们只需要让 synchronized 关键字作用于方法和方法快就可以了！

synchronized 修饰的方法，会默认的把调用该方法的对象载体的同步监视锁拿到。（获取的方法很简单，让这个对象作为同步监视器就完事了）

弊端：

锁的粒度较大：如果整个方法都被synchronized修饰，即使其中只有一小部分代码需要同步，那么整个方法体的代码也都会被锁住。这可能导致性能瓶颈，因为只有真正需要同步的部分才应该时被锁住的。
无法中断：一旦线程进入synchronized方法，其他线程必须等待该线程执行完毕才能获取锁。这意味着，如果一个线程在等待锁的过程中被中断，它会一直等待下去，直到再次获取到锁或者被其他方式唤醒。这就是个隐藏的炸弹了~
无法设置超时：synchronized方法无法设置超时期限，如果一个线程试图获取锁时不能在指定的时间内获取到，就无法进行其他处理。
难以适应复杂的同步需求：使用synchronized方法，只能用于基本的同步需求。对于更复杂的同步需求，例如支持多个条件，可能需要使用更灵活的同步工具，比如java.util.concurrent包中的ReentrantLock。
锁的对象还有很大的局限性，有的时候为了符合逻辑，我们方法的对象可能并不是那个共享的资源。这就导致了我们没法将其上锁。。

总体来说：synchronized 只能算是最简单的同步方法之一

public class 同步方法 {
    public static void main(String[] args) {
        Numnum num = new Numnum();

        new Thread(num,"A").start();
        new Thread(num,"B").start();


    }

}

class Numnum implements Runnable {
    private int num = 100;

    @Override
    public synchronized void run() { // 给方法 加 synchronized 那么调用它的 对象就能拿到 锁

        while(num > 0)
        {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            System.out.println(Thread.currentThread().getName() + "-->" + (num--));
        }
    }
}

你会发现，A 和 B 都是这样子的处理，但是 run 方法加了 synchronized 关键字，这也就意味着当 A 拿到锁之后，如果不处理完 run 方法，它时不会释放锁的。而等 A 执行完 run 之后，num 也等于 0 了。则 B 不会去 num -- 直接就完事了。

当然了，我们也有根本拿不到正确锁的情况，如下：

public class 竞态条件 {
    // 共享计数器
    private static int counter = 0;

    synchronized public static void main(String[] args) throws InterruptedException {
        // 创建两个线程，分别定义线程的执行逻辑
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                // 读取计数器的值
                int value = counter;
                // 执行递增操作
                value = value + 1;
                // 将结果写回计数器
                counter = value;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                // 读取计数器的值
                int value = counter;
                // 执行递增操作
                value = value + 1;
                // 将结果写回计数器
                counter = value;
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        thread1.join();
        thread2.join();

        // 显示计数器的最终值
        System.out.println("最终计数器值: " + counter);
    }
}

7.2 synchronized 代码块（常用）

synchronized 代码块就是为了解决获取正确对象锁的问题而存在的！

同步块：synchronized(Obj){处理事务的代码} /* 待锁的对象 */

Obj 可以是任何对象，但是推荐使用共享的那块儿资源作为同步监视器

public class 同步代码块 {
    // 共享计数器
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程，分别定义线程的执行逻辑
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized(同步代码块.class){
                    // 读取计数器的值
                    int value = counter;
                    // 执行递增操作
                    value = value + 1;
                    // 将结果写回计数器
                    counter = value;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized(同步代码块.class){
                    // 读取计数器的值
                    int value = counter;
                    // 执行递增操作
                    value = value + 1;
                    // 将结果写回计数器
                    counter = value;
                }
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        thread1.join();
        thread2.join();

        // 显示计数器的最终值
        System.out.println("最终计数器值: " + counter);
    }
}

【作业】：如何在使用 synchronized 方法的情况下，也把上述的例子解决冲突？

7.3 悲观锁和乐观锁

synchronized 采用的是悲观锁策略

悲观锁和乐观锁都属于并发控制的机制，即悲观锁和乐观锁是并发控制的两种不同策略。

悲观锁：
- 悲观锁的基本思想是，每次访问共享资源之前，都会先获取锁，确保在同一时刻只有一个线程能够访问共享资源。
- 典型的悲观锁的实现是通过使用互斥锁（例如，Java中的synchronized关键字或ReentrantLock类）来确保同一时刻只有一个线程能够执行关键代码段。
乐观锁：
- 乐观锁的基本思想是，认为在大多数情况下，对共享资源的访问是不会发生冲突的。因此，它不会使用互斥锁，而是采用一种更轻量级的方式。
- 典型的乐观锁的实现是通过版本号（Versioning）或时间戳（Timestamp）等机制来进行控制。每个线程在访问共享资源之前，先获取版本号，然后在修改时检查版本号是否被其他线程修改过。

悲观锁的开销肯定是大的，但绝对安全！并且，尽管乐观锁减少了互斥锁的开销，但需要额外的机制来处理冲突。如果并发冲突的概率较高，那么乐观锁的效果可能不如悲观锁。

7.4 死锁现象

7.4.1 死锁的理解

多个线程各自占有一些共享资源，并且互相等待着其它线程占有资源使用释放锁，才能运行，而导致两个或者多个线程都在等待对方释放锁，最后会出现都阻塞状态的情形（假死）。某一个同步块同时拥有 “两个以上对象的锁” 时，就可能会发生 "死锁"问题 。

举例：两个线程互相想操作对方的资源，但是双方都不想给，就形成了死锁

原因：时间切换频率太快，可能两个线程一下子直接就获取了双方的锁

然后造成了双阻塞。这样就会造成假死！JVM 会自动终止程序！ 这就是死锁现象

7.4.2 导致死锁的原因

循环等待（Circular Wait）：
- 多个线程形成一个循环等待的环路，每个线程都在等待其他线程持有的资源，导致所有线程都无法继续执行。
互斥条件（Mutual Exclusion）：
- 线程请求的资源具有互斥性，即一次只能被一个线程占用。如果一个线程持有某个资源，其他线程必须等待，这可能导致死锁。
持有并等待（Hold and Wait）：
- 一个线程持有某个资源的同时等待另一个线程持有的资源，而其他线程可能在等待第一个线程持有的资源，形成相互等待。这种也是比较常见的
不可剥夺条件（Non-preemption）：
- 已经被一个线程持有的资源不能被其他线程抢占，只能由持有它的线程主动释放。如果线程持有资源并且在等待其他资源时无法释放已经持有的资源，可能导致死锁。
避免死锁的关键在于破坏上述条件之一或多个。一些常见的预防死锁的方法包括：
- 按序获取锁：确保所有线程按照相同的顺序获取锁，从而避免循环等待。
- 使用超时机制：在获取锁的时候设置一个超时，如果超过一定时间未能获取到锁，就放弃或者尝试其他处理。是解决不可剥夺条件的一个方法
- 一次性获取所有需要的资源（资源分配图方法）：一种有效的方法是在开始执行之前，一次性获取所有需要的资源。如果无法获取到所有资源，线程可以释放已经获取的资源，并等待重新获取所有资源。这种方法可以防止"持有并等待"的情况。

public class 死锁 {
    static String s1 = "线程1的资源";
    static String s2 = "线程2的资源";

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (s1){
                System.out.println("我是线程1 => 我有" + s1);
                synchronized (s2){
                    System.out.println("我是线程1 => 想要拿到" + s2);
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (s2){
                System.out.println("我是线程2 => 我有" + s2);
                synchronized (s1){
                    System.out.println("我是线程2 => 想要拿到" + s1);
                }
            }
        });
        thread1.start();
        thread2.start();

    }
}

不就是因为同步锁里面又嵌套了一个同步锁吗。

7.4.2 检测死锁

打开终端，输入 jps 就会显示当前运行的所有 Java 程序的进程 ID
然后找到对应程序的 ID 直接输入 jstack 进程ID 就完事了
也可以输入 jconsole 打开检测控制台

其实这种方式是更加方便的。

这种方式，更多的是去远程检测部署在服务器上的 Java 程序！

第八章·关于一些并行操作

8.1 parallelStream() 并行流

所有的集合类都可以 集合对象.parallelStream() 来获得并行流，它的作用是启用多线程来辅助我们进行一些关于流的操作。这样可以更加的高效！

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 4, 5, 2, 9, 3, 6, 0));
    list
            .parallelStream()    //获得并行流
            .forEach(i -> System.out.println(Thread.currentThread().getName()+" -> "+i));
}

forEachOrdered()：

如果流具有已定义的冲突顺序方法，则以该流的冲突顺序方法为该流的每个元素作为使用者(Consumer)执行操作。
这是终端操作。
这种方法保证了在顺序流和并行流中都按顺序执行。

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 4, 5, 2, 9, 3, 6, 0));
    list
            .parallelStream()    //获得并行流
            .forEachOrdered(System.out::println);
}

8.2 Arrays 数组工具类中的并行方法

parallelSort 方法：

用于并行地对数组进行排序。该方法使用 ForkJoinPool 来充分利用多核处理器进行排序操作，提高排序性能。

// 例子：并行排序
int[] array = {4, 2, 7, 1, 9, 5};
Arrays.parallelSort(array);

parallelPrefix 方法：

用于对数组进行并行的前缀累加操作。例如，将数组中的每个元素替换为该元素及其前面所有元素的和。

// 例子：并行前缀累加
int[] array = {1, 2, 3, 4, 5};
Arrays.parallelPrefix(array, (x, y) -> x + y);

parallelSetAll 方法：

用于使用并行计算设置数组的元素值。该方法接受一个 IntUnaryOperator 函数，该函数用于计算数组中每个索引位置的元素值。

// 例子：并行设置数组元素值
int[] array = new int[5];
Arrays.parallelSetAll(array, i -> i * i);

parallelForEach 方法：

用于对数组中的每个元素执行给定的操作。该方法接受一个 Consumer 函数，该函数对数组中的每个元素执行操作。

// 例子：并行遍历数组并执行操作
int[] array = {1, 2, 3, 4, 5};
Arrays.parallelForEach(array, System.out::println);

8.3 集合类与多线程之间的问题

由于集合类并没有考虑到与多线程联用的情况，所以不建议使用之前学习的集合类与多线程进行紧密的配合。因为它们线程是不安全的，当然，如果要非得用，那你就得自己解决并发问题了。

8.3.1 老的集合类（但线程安全）

Vector 是在 Java 早期的时候就有的，它们的线程是安全的，可以随意的与多线程搭配使用。
Hashtable<Key的类型, Val 类型> 可以代替 Map 作为线程安全的集合类使用。

这俩集合类里面的方法都加了锁，所以当然我们可以频繁的与多线程一起联用了。

只不过呢，Java 也考虑到了这种情况，所以它也发明了很多专门勇于并发编程的集合类，这个我们现在暂时不做讲解。

第九章·生产者与消费者问题

这个问题就是老生常谈的问题了，我相信很多讲课的，或者学习多线程的，最后都会去练习这个问题！

问题描述：如果说存在n个生产者在工厂里生产产品，和m个消费者去进行产品的消耗，那么如何保证消费者在消耗时，必须产品数量 > 0，而生产者在生产时是否可以限制一定的上限循循渐进的生产。

提示：可能你需要一个第三方的容器，用来做中介，可以更好的解决这个问题！

这个容器，可以帮助你存储产品信息和记录产品的数量！符合面向对象编程思想

这个容器，最好是拥有生产和消费方法，这样的话我们直接就可以在这两个方法上用 synchorized 很方便的解决并发问题中的竞态条件！

import java.util.LinkedList;

// 我们自己新建一个 共享缓冲区的 类，里面封装 实际容器 和 容器大小
// 有点儿类似于 超级数组，是吧 ~
class SharedBuffer {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private int capacity;

    public SharedBuffer(int capacity) {
        this.capacity = capacity;
    }

    synchronized public void produce(int item) throws InterruptedException {
        while (buffer.size() == capacity) {
            System.out.println("Buffer is full. Producer is waiting...");
            wait();
        }

        buffer.add(item);
        System.out.println("Produced: " + item);

        // 通知消费者可以消费了
        notify();
    }

    synchronized public int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            System.out.println("Buffer is empty. Consumer is waiting...");
            wait();
        }

        int item = buffer.removeFirst();
        System.out.println("Consumed: " + item);

        // 通知生产者可以生产了
        notify();

        return item;
    }
}

class Producer implements Runnable {
    private SharedBuffer buffer;

    public Producer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                buffer.produce(i);
                Thread.sleep(1000); // 模拟 1秒 生产一个 产品
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产者 执行任务完毕！");
    }
}

class Consumer implements Runnable {
    private SharedBuffer buffer;

    public Consumer(SharedBuffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                int item = buffer.consume();
                Thread.sleep(3000); // 模拟 3秒 消耗一个 产品
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费者 执行任务完毕！");
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer(2);

        Thread producerThread = new Thread(new Producer(buffer));
        Thread consumerThread = new Thread(new Consumer(buffer));

        producerThread.start();
        consumerThread.start();
    }
}

我们在这里可以调节消费者和生产者消费和生产的速率，即 sleep() 延迟时间就可以模拟处理，然后我们就可以观察到想要观察的任何现象。

第二种写法：

import java.util.LinkedList;

class Producer implements Runnable {
    private LinkedList<Integer> list;
    private int maxSize;

    public Producer(LinkedList<Integer> list, int maxSize) {
        this.list = list;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                produce(i);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产者 执行任务完毕！");
    }

    public void produce(int item) {
        synchronized (this.list) {
            while (this.list.size() == maxSize) {
                System.out.println("容器已满，请稍后再生产！");
                try {
                    this.list.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            this.list.add(item);
            System.out.println("Produced: " + item);
            this.list.notify();
        }
    }
}

class Consumer implements Runnable {
    private LinkedList<Integer> list;

    public Consumer(LinkedList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                int item = consume(i);
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费者 执行任务完毕！");
    }

    public int consume(int item) {
        synchronized (this.list) {
            while (this.list.size() == 0) {
                System.out.println("产品没了，别消费了！");
                try {
                    this.list.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            int consumedItem = this.list.removeFirst();
            System.out.println("Consumed: " + consumedItem);
            this.list.notify();
            return consumedItem;
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();

        Thread producerThread = new Thread(new Producer(list, 2));
        Thread consumerThread = new Thread(new Consumer(list));

        producerThread.start();
        consumerThread.start();
    }
}

posted @ 2024-01-11 22:34 小哞^同^学的技术博客阅读(33) 评论(0) 编辑收藏举报

刷新页面返回顶部

MuQuanyu's Blog