itLaity

万文详解JUC（超详细）

生命无罪，健康万岁，我是laity。

我曾七次鄙视自己的灵魂：

第一次，当它本可进取时，却故作谦卑；

第二次，当它在空虚时，用爱欲来填充；

第三次，在困难和容易之间，它选择了容易；

第四次，它犯了错，却借由别人也会犯错来宽慰自己；

第五次，它自由软弱，却把它认为是生命的坚韧；

第六次，当它鄙夷一张丑恶的嘴脸时，却不知那正是自己面具中的一副；

第七次，它侧身于生活的污泥中，虽不甘心，却又畏首畏尾。

什么是JUC?

JUC：指的是java.util三个并发编程工具包的简称

java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks

java.util 工具包

线程和进程

线程和进程，如果不能使用一句话说出来的 - 技术不扎实！

进程：一个程序，QQ.exe - 程序的集合
- 一个进程往往包含多个线程，至少包含一个！
- Java默认有几个线程？2个：main、GC线程
线程：开了一个进程notepad++，写字 - 会自动保存(线程负责的！)

在Java中开启线程的方式：

Thread
Runnable
Callable：实现Callable接口 + FutureTask（可以拿到返回值，可以处理异常） jdk1.5
线程池

此处为语雀内容卡片，点击链接查看：https://www.yuque.com/laity-champion/base/fk2vsqq25g3egpyl

问题：Java真的可以开启线程吗？

先说结论：不可以的开启

    public static void main(String[] args) {
        new Thread().start();
    }

点击start(); 查看源码

在Java等编程语言中，“native” 用来表示由本地代码（通常是用C或C++编写的）实现的方法。这些方法可以通过 Java Native Interface（JNI）调用。这样的方法通常涉及对底层系统或硬件的直接访问，提供了与平台相关的功能。

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	// 本地方法，调用底层的C++, Java是无法直接操作硬件
    private native void start0();

并发和并行

并发：并发编程 -> 多线程操作同一个资源
- CPU只有一核，模拟出来多线程 - 天下武功，唯快不破！快速交替
- 并发是指系统能够同时处理多个独立的任务或操作的能力。这并不一定意味着这些任务在同一时刻都在执行，而是在宏观上给人一种同时执行的感觉。并发的目标是提高系统资源的利用率，更有效地处理任务。
- 并发的目标是提高系统的吞吐量、资源利用率和响应性。在多核系统中，多线程和多进程可以实现并发，充分利用多核处理器的性能。
并行：多个人一起行走
- CPU多核，多个线程可以同时执行；
- 并行是指系统实际上同时执行多个任务或操作，即多个任务在同一时刻内执行。与并发不同，并行关注的是同时发生的事件，而不仅仅是在短时间内交替发生。
- 并行的目标是更快地完成任务，通过同时处理多个子任务，从而提高整体性能。在硬件层面，多核处理器、GPU等可以实现并行。

并发编程本质

充分利用CPU资源 -> 提高效率

管程

管程是一种用于同步和互斥的高级抽象。它包含了共享数据和用于访问这些数据的一组过程。管程提供了一种结构化的方法来确保在并发程序中对共享资源的访问是安全的。Java中的 synchronized 关键字就是一种管程的实现。
- 管程是一种用于解决多线程并发问题的高级同步机制。它结合了数据（共享资源）和程序（对共享资源的操作）；
- 在Java中，synchronized 关键字和 wait()、notify() 方法是实现管程的基本工具。管程提供了对共享资源的互斥访问和条件等待的支持。

用户线程

用户线程是由应用程序开发人员创建和控制的线程。这些线程在用户空间中运行，而不需要内核支持。用户线程的创建、调度和销毁都由用户空间的线程库来管理，而不涉及操作系统内核的介入。

用户线程由应用程序开发人员创建和控制，线程的创建、调度和销毁都由用户空间的线程库来管理。
用户线程相对较轻量，线程切换成本较低。然而，它们受限于操作系统的调度，可能会被阻塞。

守护线程

守护线程是在程序运行时在后台提供服务的线程。当所有的非守护线程结束时，程序会退出，不会等待守护线程执行完毕。典型的守护线程例子是垃圾回收线程。在Java中，可以通过 setDaemon(true) 方法将线程设置为守护线程。

守护线程在程序运行时在后台提供服务，典型的例子是垃圾回收线程。
当所有的非守护线程结束时，程序会退出，而不会等待守护线程执行完毕。守护线程通常用于执行一些后台任务，不影响程序的正常运行。

回顾多线程

线程有几个状态？

Thread.State 线程枚举类可以自行查看

/** * A thread state. A thread can be in one of the following states: * * {@link #NEW} * A thread that has not yet started is in this state. * * {@link #RUNNABLE} * A thread executing in the Java virtual machine is in this state. * * {@link #BLOCKED} * A thread that is blocked waiting for a monitor lock * is in this state. * * {@link #WAITING} * A thread that is waiting indefinitely for another thread to * perform a particular action is in this state. * * {@link #TIMED_WAITING} * A thread that is waiting for another thread to perform an action * for up to a specified waiting time is in this state. * * {@link #TERMINATED} * A thread that has exited is in this state. * * * *

* A thread can be in only one state at a given point in time. * These states are virtual machine states which do not reflect * any operating system thread states. * * @since 1.5 * @see #getState */ public enum State { // 线程新生 NEW, // 线程运行 RUNNABLE, // 线程阻塞 BLOCKED, // 线程等待 WAITING, // 超时等待 - 死死的等 TIMED_WAITING, // 线程终止 TERMINATED; }

可以看到有6个状态，分别是：

线程新生
线程运行
线程阻塞
线程等待
超时等待 - 死死的等
线程终止

wait和sleep区别

来自不同的类
- wait -> Object
- sleep -> Thread
关于锁的释放
- wait -> 会释放锁
- sleep -> 睡觉了，抱着锁睡觉，不会释放！
使用的范围不同
- wait -> 必须在同步代码块中睡
- sleep -> 可以在任何地方睡
是否需要捕获异常
- wait -> 不需要捕获异常 - 但是有中断异常需要捕获
- sleep -> 必须要捕获异常 - 因为有可能发送超时等待问题

Lock锁(重点)

传统 Synchronized

package com.laity.demo1;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo1.SaleTicketDemo01
 * @Date: 2023年11月21日 23:26
 * @Description: 基本卖票例子
 * 真正的多线程开发，公司中的开发，降低耦合性（高内聚、低耦合）
 * 线程就是一个单独的资源类，没有附属的操作
 * 资源类包含：1、属性；2、方法
 */

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 多线程操作
        // 并发：多个线程操作同一个资源类,
        // 操作：把资源类丢进线程
        Ticket ticket = new Ticket();
        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程A").start();

        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程B").start();

        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程C").start();
    }
}

// 单独的资源类  OOP编程
class Ticket {
    // 属性、方法
    private int number = 50;

    // 卖票的方法
    // synchronized 本质就是队列，锁
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + " - 卖出了第" + (number--) + "张票" + ",剩余" + number);
        }
    }
}

结果就会很有顺序，不加synchronized就会很乱：

线程A - 卖出了第10张票,剩余9
线程A - 卖出了第9张票,剩余8
线程A - 卖出了第8张票,剩余7
线程A - 卖出了第7张票,剩余6
线程A - 卖出了第6张票,剩余5
线程A - 卖出了第5张票,剩余4
线程A - 卖出了第4张票,剩余3
线程A - 卖出了第3张票,剩余2
线程A - 卖出了第2张票,剩余1
线程A - 卖出了第1张票,剩余0

Process finished with exit code 0

Lock接口

实现类

公平锁：十分公平，先来后到（阳光普照，效率相对低一些）

非公平锁：十分不公平，可以插队（默认，可能会造成线程饿死，但是效率高）

package com.laity.demo1;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo1.SaleTicketDemo01
 * @Date: 2023年11月21日 23:26
 * @Description: 基本卖票例子
 * 真正的多线程开发，公司中的开发，降低耦合性（高内聚、低耦合）
 * 线程就是一个单独的资源类，没有附属的操作
 * 资源类包含：1、属性；2、方法
 */

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 多线程操作
        // 并发：多个线程操作同一个资源类,
        // 操作：把资源类丢进线程
        Ticket2 ticket = new Ticket2();
        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程A").start();

        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程B").start();

        new Thread(() -> {
            for (int j = 0; j < 30; j++) {
                ticket.sale();
            }
        }, "线程C").start();
    }
}

// 单独的资源类  OOP编程
// lock三部曲
// 1、new ReentrantLock();
// 2、lock.lock() // 加锁
// 3、finally -> lock.unlock(); // 解锁
class Ticket2 {
    // 属性、方法
    private int number = 50;

    // 使用 juc lock锁
    Lock lock = new ReentrantLock();

    // 卖票的方法
    public void sale() {
        // 加锁
        lock.lock();

        // ctrl + alt + t 快捷键
        try {
            // 业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + " - 卖出了第" + (number--) + "张票" + ",剩余" + number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}

效果与Synchronized一样

Synchronized和Lock的区别

1.synchronized 是内置的Java关键字，Lock是Java的一个接口

2.synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁

3.synchronized 会自动释放锁，Lock必须手动释放锁！如果不释放锁，会造成死锁

4.synchronized 线程一在获得锁的情况下阻塞了，第二个线程就只能傻傻的等着；Lock就不一定会等待下去

5.synchronized 可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平/公平（可以自己设置，默认非公平锁）

6.synchronized 适合锁少量的同步代码；Lock适合锁大量同步代码！

7.Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者性能是差不多的，而当竞争资源非常激烈时（即大量线程同时竞争），此时Lock的性能要远远优于synchronized

问题：锁是什么，如何判断锁的是谁？

个人理解：锁是让一个线程在时间内走一个执行代码，锁的是多个线程锁共享的对象(标志位、临界资源)和Class（static修饰）。

生产者和消费者问题

Synchronized版本 -> wait(等待)、notify（唤醒）

JUC版本lock -> Condition

面试四大考点：单例模式单例设计模式-复习、排序算法、生产者和消费者问题、死锁

Synchronized版本生产者和消费者问题

Synchronized版本 -> wait(等待)、notify（唤醒） : 传统的三剑客

package com.laity.demo2;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo2.Communication01
 * @Date: 2023年11月22日 00:25
 * @Description: 线程直接通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行  t1 t2 两个线程操作同一个变量，进行 +1 | -1
 */

public class Communication01 {
    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        Data data = new Data();
        t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

// 资源类：线程就是一个单独的资源类，没有附属的操作
// 判断等待、业务、通知
class Data {
    private int number = 0;

    // +1
    // 只要有并发就一定要加锁
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            // 等待
            this.wait();
        }
        // 业务
        number++;
        // 加1后通知其它线程我加一完毕了
        System.out.println(Thread.currentThread().getName() + "==>" + number);
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            // 等待
            this.wait();
        }
        number--;
        // 通知其它线程我减一完毕了
        System.out.println(Thread.currentThread().getName() + "==>" + number);
        this.notifyAll();
    }
}

输出结果：

t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0
t1==>1
t2==>0

两个线程可以看到结果是很正常的；但是也问题存在，4个线程或者8个线程，就不安全了

Synchronized多线程导致不安全

package com.laity.demo2;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo2.Communication01
 * @Date: 2023年11月22日 00:25
 * @Description: 线程直接通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行  t1 t2 两个线程操作同一个变量，进行 +1 | -1
 */

public class Communication01 {
    static Thread t1 = null, t2 = null, t3 = null, t4 = null;

    public static void main(String[] args) {
        Data data = new Data();
        t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t3 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t3");

        t4 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

// 资源类：线程就是一个单独的资源类，没有附属的操作
// 判断等待、业务、通知
class Data {
    private int number = 0;

    // +1
    // 只要有并发就一定要加锁
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            // 等待
            this.wait();
        }
        // 业务
        number++;
        // 加1后通知其它线程我加一完毕了
        System.out.println(Thread.currentThread().getName() + "==>" + number);
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            // 等待
            this.wait();
        }
        number--;
        // 通知其它线程我减一完毕了
        System.out.println(Thread.currentThread().getName() + "==>" + number);
        this.notifyAll();
    }
}

输出结果：

t1==>1
t3==>0
t4==>1
t1==>2
t4==>3
t2==>2
t2==>1
t2==>0
t3==>-1
t3==>-2
t3==>-3
t3==>-4
t3==>-5
t3==>-6
t3==>-7
t3==>-8
t3==>-9
t2==>-10
t2==>-11
t2==>-12
t2==>-13
t2==>-14
t2==>-15
t2==>-16
t4==>-15
t1==>-14
t4==>-13
t1==>-12
t4==>-11
t1==>-10
t4==>-9
t1==>-8
t4==>-7
t1==>-6
t4==>-5
t1==>-4
t4==>-3
t1==>-2
t4==>-1
t1==>0

四个线程的运行结果就很明显了，可以看出是有问题的，但是问题是由什么造成的呢？

导致Synchronized多线程不安全的原因

虚假唤醒 - JDK源码文档中有提及：

解决线程虚假唤醒

由if判断改为官方的while判断即可

输出结果：

D:\Java\JDK\bin\java.exe "-javaagent:E:\IdeaInstall\IntelliJ IDEA 2020.3.4\lib\idea_rt.jar=64439:E:\IdeaInstall\IntelliJ IDEA 2020.3.4\bin" -Dfile.encoding=UTF-8 -classpath D:\java\JDK\jre\lib\charsets.jar;D:\java\JDK\jre\lib\deploy.jar;D:\java\JDK\jre\lib\ext\access-bridge-64.jar;D:\java\JDK\jre\lib\ext\cldrdata.jar;D:\java\JDK\jre\lib\ext\dnsns.jar;D:\java\JDK\jre\lib\ext\jaccess.jar;D:\java\JDK\jre\lib\ext\jfxrt.jar;D:\java\JDK\jre\lib\ext\localedata.jar;D:\java\JDK\jre\lib\ext\mysql-connector-java-5.1.48.jar;D:\java\JDK\jre\lib\ext\nashorn.jar;D:\java\JDK\jre\lib\ext\sunec.jar;D:\java\JDK\jre\lib\ext\sunjce_provider.jar;D:\java\JDK\jre\lib\ext\sunmscapi.jar;D:\java\JDK\jre\lib\ext\sunpkcs11.jar;D:\java\JDK\jre\lib\ext\zipfs.jar;D:\java\JDK\jre\lib\javaws.jar;D:\java\JDK\jre\lib\jce.jar;D:\java\JDK\jre\lib\jfr.jar;D:\java\JDK\jre\lib\jfxswt.jar;D:\java\JDK\jre\lib\jsse.jar;D:\java\JDK\jre\lib\management-agent.jar;D:\java\JDK\jre\lib\plugin.jar;D:\java\JDK\jre\lib\resources.jar;D:\java\JDK\jre\lib\rt.jar;D:\LaityWork\architecture\foodie-dev\target\classes;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter\2.1.5.RELEASE\spring-boot-starter-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot\2.1.5.RELEASE\spring-boot-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-context\5.1.7.RELEASE\spring-context-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-autoconfigure\2.1.5.RELEASE\spring-boot-autoconfigure-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-logging\2.1.5.RELEASE\spring-boot-starter-logging-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\logging\log4j\log4j-to-slf4j\2.11.2\log4j-to-slf4j-2.11.2.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\logging\log4j\log4j-api\2.11.2\log4j-api-2.11.2.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\slf4j\jul-to-slf4j\1.7.26\jul-to-slf4j-1.7.26.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\javax\annotation\javax.annotation-api\1.3.2\javax.annotation-api-1.3.2.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-core\5.1.7.RELEASE\spring-core-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-jcl\5.1.7.RELEASE\spring-jcl-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\yaml\snakeyaml\1.23\snakeyaml-1.23.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-web\2.1.5.RELEASE\spring-boot-starter-web-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-json\2.1.5.RELEASE\spring-boot-starter-json-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\core\jackson-databind\2.9.8\jackson-databind-2.9.8.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\core\jackson-core\2.9.8\jackson-core-2.9.8.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.9.8\jackson-datatype-jdk8-2.9.8.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.9.8\jackson-datatype-jsr310-2.9.8.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\module\jackson-module-parameter-names\2.9.8\jackson-module-parameter-names-2.9.8.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-tomcat\2.1.5.RELEASE\spring-boot-starter-tomcat-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\tomcat\embed\tomcat-embed-core\9.0.19\tomcat-embed-core-9.0.19.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\tomcat\embed\tomcat-embed-el\9.0.19\tomcat-embed-el-9.0.19.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.19\tomcat-embed-websocket-9.0.19.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\hibernate\validator\hibernate-validator\6.0.16.Final\hibernate-validator-6.0.16.Final.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\javax\validation\validation-api\2.0.1.Final\validation-api-2.0.1.Final.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\jboss\logging\jboss-logging\3.3.2.Final\jboss-logging-3.3.2.Final.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-web\5.1.7.RELEASE\spring-web-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-beans\5.1.7.RELEASE\spring-beans-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-webmvc\5.1.7.RELEASE\spring-webmvc-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-expression\5.1.7.RELEASE\spring-expression-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-aop\2.1.5.RELEASE\spring-boot-starter-aop-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-aop\5.1.7.RELEASE\spring-aop-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\aspectj\aspectjweaver\1.9.4\aspectjweaver-1.9.4.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-configuration-processor\2.1.5.RELEASE\spring-boot-configuration-processor-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\projectlombok\lombok\1.18.10\lombok-1.18.10.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\mysql\mysql-connector-java\5.1.47\mysql-connector-java-5.1.47.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\mybatis\spring\boot\mybatis-spring-boot-starter\2.1.0\mybatis-spring-boot-starter-2.1.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\boot\spring-boot-starter-jdbc\2.1.5.RELEASE\spring-boot-starter-jdbc-2.1.5.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\zaxxer\HikariCP\3.2.0\HikariCP-3.2.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-jdbc\5.1.7.RELEASE\spring-jdbc-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\spring-tx\5.1.7.RELEASE\spring-tx-5.1.7.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\mybatis\spring\boot\mybatis-spring-boot-autoconfigure\2.1.0\mybatis-spring-boot-autoconfigure-2.1.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\mybatis\mybatis\3.5.2\mybatis-3.5.2.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\mybatis\mybatis-spring\2.0.2\mybatis-spring-2.0.2.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-spring-boot-starter\2.1.5\mapper-spring-boot-starter-2.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-core\1.1.5\mapper-core-1.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\javax\persistence\persistence-api\1.0\persistence-api-1.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-base\1.1.5\mapper-base-1.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-weekend\1.1.5\mapper-weekend-1.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-spring\1.1.5\mapper-spring-1.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-extra\1.1.5\mapper-extra-1.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\tk\mybatis\mapper-spring-boot-autoconfigure\2.1.5\mapper-spring-boot-autoconfigure-2.1.5.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\github\pagehelper\pagehelper-spring-boot-starter\1.2.12\pagehelper-spring-boot-starter-1.2.12.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\github\pagehelper\pagehelper-spring-boot-autoconfigure\1.2.12\pagehelper-spring-boot-autoconfigure-1.2.12.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\github\pagehelper\pagehelper\5.1.10\pagehelper-5.1.10.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\github\jsqlparser\jsqlparser\2.0\jsqlparser-2.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\commons-codec\commons-codec\1.11\commons-codec-1.11.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\apache\commons\commons-lang3\3.4\commons-lang3-3.4.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\commons-io\commons-io\2.4\commons-io-2.4.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-swagger2\2.4.0\springfox-swagger2-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\swagger\swagger-annotations\1.5.6\swagger-annotations-1.5.6.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\swagger\swagger-models\1.5.6\swagger-models-1.5.6.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\jackson\core\jackson-annotations\2.9.0\jackson-annotations-2.9.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-spi\2.4.0\springfox-spi-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-core\2.4.0\springfox-core-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-schema\2.4.0\springfox-schema-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-swagger-common\2.4.0\springfox-swagger-common-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-spring-web\2.4.0\springfox-spring-web-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\google\guava\guava\18.0\guava-18.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\fasterxml\classmate\1.4.0\classmate-1.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\plugin\spring-plugin-core\1.2.0.RELEASE\spring-plugin-core-1.2.0.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\springframework\plugin\spring-plugin-metadata\1.2.0.RELEASE\spring-plugin-metadata-1.2.0.RELEASE.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\io\springfox\springfox-swagger-ui\2.4.0\springfox-swagger-ui-2.4.0.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\com\github\xiaoymin\swagger-bootstrap-ui\1.6\swagger-bootstrap-ui-1.6.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\slf4j\slf4j-api\1.7.21\slf4j-api-1.7.21.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\org\slf4j\slf4j-log4j12\1.7.21\slf4j-log4j12-1.7.21.jar;D:\java\Maven\apache-maven-3.6.3\mvn_resp\log4j\log4j\1.2.17\log4j-1.2.17.jar com.laity.demo2.Communication01
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0
t1==>1
t3==>0
t4==>1
t2==>0

Process finished with exit code 0

可以看到结果正常，已解决线程虚假唤醒问题。

JUC版本的生产者和消费者问题

通过java.util.concurrent.locks 的Lock找到Condition

代码实现：

package com.laity.demo2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo2.Communication02
 * @Date: 2023年11月22日 21:51
 * @Description: JUC版本 生产者和发布者问题
 */

public class Communication02 {

    static Thread t1 = null, t2 = null, t3 = null, t4 = null;

    public static void main(String[] args) {
        DataSource data = new DataSource();
        t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t3 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t3");

        t4 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

// 资源类：线程就是一个单独的资源类，没有附属的操作
class DataSource {
    private int number = 0;

    // 使用JUC创建锁
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                // 等待
                notFull.await();
            }
            // 业务
            number++;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 通知唤醒
            notFull.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {
                // 等待
                notFull.await();
            }
            // 业务
            number--;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 通知唤醒
            notFull.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

结果没有问题，但是Condition的优势在哪里呢？这和Synchronized的完全没有区别啊？

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，一定有优势和补充！

采用JUC的Condition优势

可以精准的通知和唤醒线程

代码测试：

package com.laity.demo2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.demo2.Communication03
 * @Date: 2023年11月22日 22:19
 * @Description: 基于JUC的Condition实现精准的通知和唤醒线程
 * 需求 t1执行完，执行t2，t2执行完，执行t3，t3执行完，执行t4,t4执行完 调用t1
 */

public class Communication03 {
    static Thread t1 = null, t2 = null, t3 = null, t4 = null;
    public static void main(String[] args) {
        DataService data = new DataService();
        t1 = new Thread(data::printA, "t1");

        t2 = new Thread(data::printB, "t2");

        t3 = new Thread(data::printC, "t3");

        t4 = new Thread(data::printD, "t4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

// 唯一资源类
class DataService {
    // 使用JUC创建锁
    private final Lock lock = new ReentrantLock();
    // 监视器
    private final Condition condition1 = lock.newCondition();
    private final Condition condition2 = lock.newCondition();
    private final Condition condition3 = lock.newCondition();
    private final Condition condition4 = lock.newCondition();

    // 模拟一个标识位
    private int number = 1; // 1-t1;2-t2;3-t3;4-t4

    public void printA(){
        lock.lock();
        try {
            // 业务代码 : while条件判断 -> 程序执行 -> 通知唤醒
            while (number!=1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + " - number == 1");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            // 业务代码 : while条件判断 -> 程序执行 -> 通知
            while (number!=2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + " - number == 2");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            // 业务代码 : while条件判断 -> 程序执行 -> 通知
            while (number!=3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + " - number == 3");
            number = 4;
            condition4.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printD(){
        lock.lock();
        try {
            // 业务代码 : while条件判断 -> 程序执行 -> 通知
            while (number!=4) {
                condition4.await();
            }
            System.out.println(Thread.currentThread().getName() + " - number == 4");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出结果：

t1number == 1
t2number == 2
t3number == 3
t4number == 4

8锁现象

在Java中，"8锁"问题通常指的是在多线程环境下对对象的锁定问题，特别是在使用synchronized关键字时可能遇到的情况。这个问题涉及到Java中的对象锁、方法锁以及静态方法锁。

具体来说，"8锁"问题通常涉及以下几种情况：

对象锁：

- 普通同步方法，锁是当前实例对象。
- 静态同步方法，锁是当前类的Class对象。
- 同步方法块，锁是括号里面的对象。

方法参数问题：

- 如果两个线程访问的是同一个对象实例的不同普通同步方法，它们之间是有竞争关系的。
- 如果两个线程访问的是同一个对象的不同同步方法，一个是普通同步方法，一个是静态同步方法，它们之间也是有竞争关系的。
这里的"8锁"主要来源于这四种情况的组合，即2种对象锁（普通同步方法和同步方法块）乘以2种方法锁（普通方法和静态方法）等于8种可能的组合。

下面是一个简单的例子，展示了可能的"8锁"情况：

public class SynchronizedExample {
    public synchronized void method1() {
        // 对象锁：当前实例对象
    }

    public static synchronized void method2() {
        // 对象锁：当前类的Class对象
    }

    public void method3() {
        synchronized (this) {
            // 对象锁：括号里面的对象
        }
    }

    public static void method4() {
        synchronized (SynchronizedExample.class) {
            // 对象锁：括号里面的对象是当前类的Class对象
        }
    }
}

在多线程环境中，对于这些同步方法和同步块的组合，可能会导致不同的线程竞争锁，从而产生不同的执行结果。这就是"8锁"问题的核心。解决这个问题通常需要考虑同步的粒度、锁的选择以及代码的执行顺序等因素。

小结

锁的种类：主要有两种锁，分别是对象锁（实例锁）和类锁。
锁的粒度：分为两种，分别是粗粒度锁和细粒度锁。

下面是这8种加锁情况：

对象锁（实例锁）+ 同步方法：锁住当前实例对象。
对象锁（实例锁）+ 同步代码块：锁住括号里面的对象。
对象锁（实例锁）+ 静态方法：锁住当前类的Class对象。
对象锁（实例锁）+ 静态代码块：锁住当前类的Class对象。
类锁 + 同步方法：锁住当前类的Class对象。
类锁 + 同步代码块：锁住当前类的Class对象。
类锁 + 静态方法：锁住当前类的Class对象。
类锁 + 静态代码块：锁住当前类的Class对象。

这里涉及到了两个不同的锁：对象锁和类锁。同时，锁的粒度也有两种：粗粒度锁和细粒度锁。

在多线程环境下，如果不同的线程分别使用了这些锁的组合，可能会导致不同的线程争夺锁资源，从而产生死锁、性能下降等并发问题。理解并正确使用锁是多线程编程中非常重要的一部分，避免出现不必要的并发问题。

集合类不安全

List不安全

代码：集合类不安全 - List不安全

package com.laity.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.unsafe.ListTest
 * @Date: 2023年11月25日 21:20
 * @Description: 集合类不安全 - List不安全
 */

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        // List list = Collections.synchronizedList(arrayList);
        // List list = new Vector<>();
        // List list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            // 单线程下确实很安全，所以模拟下多下次
            // arrayList.add(UUID.randomUUID().toString().substring(0, 5));
            // System.out.println(arrayList);

            // 多线程下：异常
            /*
            Exception in thread "5" Exception in thread "1" Exception in thread "7" Exception in thread "0" java.util.ConcurrentModificationException
            java.util.ConcurrentModificationException 只要并发下，集合里面都会出现这个问题
            ConcurrentModificationException => 并发修改异常
             */
            // 并发下ArrayList是不安全的
            /*
            解决方案：
            1、将 new ArrayList<>(); 换为 new Vector<>(); 不好
            2、使用工具类 List list = Collections.synchronizedList(arrayList);
            3、使用JUC中的 List list = new CopyOnWriteArrayList<>();
                - private transient volatile Object[] array;
                volatile：使用 volatile 修饰 instance 可以确保在多线程环境下，一个线程对 instance 的修改对其他线程是可见的。
                - CopyOnWrite：写入时复制,COW 计算机程序设计领域的一种优化策略；
                    - list被多个线程调用的时候，读取到的是固定的，写入的时候避免其它线程将数据覆盖，造成数据问题(脏读)；
                    - 就是一种读写分离的思想，写入的时候复制出来，写入完再插回，保证线程安全
                - CopyOnWriteArrayList 比 Vector
                    - Vector效率低(只要使用了Synchronized就会效率低)
                    - CopyOnWriteArrayList使用的是Lock锁
             */
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(Thread.currentThread().getName() + list);
            }, String.valueOf(i)).start();
        }
    }
}

Vector JDK1.0发布的，比ArrayList发布还要早，所以不推荐

CopyOnWriteArrayList 写入时复制 - 推荐

Set不安全

package com.laity.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.laity.unsafe.SetTest
 * @Date: 2023年11月25日 21:57
 * @Description: 集合不安全 - Set集合不安全
 */

public class SetTest {
    public static void main(String[] args) {
        // Set set = new CopyOnWriteArraySet<>();
        Set<Object> set = Collections.synchronizedSet(new HashSet<>());
        // Set set = new HashSet<>();

        // 同理可证：java.util.ConcurrentModificationException ==> 并发修改异常
        /*
        解决方案：
        1、Set