JavaSE补充 | 单例模式、JDK8和JDK9中接口的新特性、多线程

妖狐艹你老母 2024-03-24 11:46 18阅读 0赞

**目录**

一：单例模式

二：JDK8和JDK9中接口的新特性

三：多线程

--------------------

#### 一：单例模式 ####

（1）何为单列模式

> 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某 个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

（2）实现思路

> 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

（3）单例模式的两种实现方式

①饿汉式：上来就先把对象创建好

package com.zl.test;
    
    public class Singleton {
        public static void main(String[] args) {
            // 获取对象
            User user1 = User.getSingle();
            User user2 = User.getSingle();
            System.out.println(user1 == user2); // true
        }
    }
    
    // 对象
    class User{
        // 私有化构造器
        private User() {
        }
        // 提供当前类的一个实例（先创建好）
        private static User single = new User();
        // 提供静态方法，返回当前类的对象
        public static User getSingle(){
            return single;
        }
    }

②懒汉式：用到的时候在进行创建

package com.zl.test;
    
    public class Singleton {
        public static void main(String[] args) {
            // 获取对象
            User user1 = User.getSingle();
            User user2 = User.getSingle();
            System.out.println(user1 == user2); // true
        }
    }
    
    // 对象
    class User{
        // 私有化构造器
        private User() {
        }
        // 提供当前类的一个实例（先不创建）
        private static User single = null;
        // 提供静态方法，返回当前类的对象
        public static User getSingle(){
           if (single == null){
               single = new User();
           }
           return single;
        }
    }

（4）饿汉式 vs 懒汉式

饿汉式：

> **特点：**立即加载，即在使用类的时候已经将对象创建完毕。
> 
> **优点：**实现起来简单；没有多线程安全问题。
> 
> **缺点：**当类被加载的时候，会初始化 static 的实例，静态变量被创建并分配内存空间，从这以后，这个 static 的实例便一直占着这块内存，直到类被卸载时，静态变量被摧毁，并释放所占有的内存；因此在某些特定条件下会耗费内存。

懒汉式：

> **特点：**延迟加载，即在调用静态方法时实例才被创建。
> 
> **优点：**实现起来比较简单；当类被加载的时候，static 的实例未被创建并分配内存空间，当静态方法第一次被调用时，初始化实例变量，并分配内存，因此在某些特定条 件下会节约内存
> 
> **缺点：**在多线程环境中，这种实现方法是完全错误的，线程不安全，根本不能保证单例的唯一性（后面会进行优化）。

（5）应用场景

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比 较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时 直接产生一个单例对象，然后永久驻留内存的方式来解决！

> ①Windows 的 Task Manager (任务管理器)就是很典型的单例模式。
> 
> ②Windows 的 Recycle Bin (回收站)也是典型的单例应用；在整个系统运行过程中，回收站一直维护着仅有的一个实例。
> 
> ③Application 也是单例的典型应用。
> 
> ④应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
> 
> ⑤数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

#### 二：JDK8和JDK9中接口的新特性 ####

**在 JDK8.0 之前，接口中只允许出现：**

> ①公共的静态的常量：其中 public static final 可以省略；
> 
> ②公共的抽象的方法：其中 public abstract 可以省略；

package com.zl.cmp;
    
    public interface CompareA {
        // 静态变量
        public static final double P_I = 3.1415926;
        double P = 1.34; // public static final可省略
        // 抽象方法(没有方法体的方法)
        public abstract void method();
        void method2(); // public abstract可省略
        
    }

**在 JDK8.0 时，接口中允许声明默认方法和静态方法：**

> ①公共的默认的方法：其中 public 可以省略，建议保留，但是 default 不能省略；
> 
> ②公共的静态的方法：其中 public 可以省略，建议保留，但是 static 不能省略；

**知识点1：**接口中声明的静态方法只能被接口来调用，不能使用其实现类进行调用（没有被实现类继承）

定义接口（静态方法）和接口的实现类

package com.zl.cmp;
    
    public interface CompareA {
        // 静态方法（有方法体的方法）
        public static void fly(){
            System.out.println("Bird can fly");
        }
    }
    
    // 接口的实现类
    class SubClass implements CompareA{
        // 静态方法不能被重写
    }

进行测试：只能本接口能调用静态方法，实现类无法调用静态方法

package com.zl.cmp;
    
    public class Test {
        public static void main(String[] args) {
            CompareA.fly(); // 可以（接口）
            SubClass.fly(); // err （实现类）
        }
    }

**知识点2：**接口中声明的默认方法可以被实现类继承，并且可以重写

定义接口（默认方法）和接口的实现类（重写默认方法）

package com.zl.cmp;
    
    public interface CompareA {
        // 默认方法(有方法体的方法)
        public default void method(){
            System.out.println("CompareA");
        }
    }
    
    // 接口的实现类
    class SubClass implements CompareA{
        // 可以重写默认方法
        @Override
        public void method() {
            System.out.println("SubClass");
        }
    }

进行测试：重写之前调用的是父类的默认方法，重写之后调用的就是子类的默认方法

package com.zl.cmp;
    
    public class Test {
        public static void main(String[] args) {
            // 创建对象
            CompareA sub = new SubClass();
            // 调用方法
            sub.method(); // SubClass
        }
    }

**知识点3：**接口冲突，类实现两个接口，而两个接口中定义了同名同参数的默认方法，此时实现类在没有重写两个接口默认方法的情况下，会报错

CompareA接口：默认方法method

public interface CompareA {
        // 默认方法(有方法体的方法)
        public default void method(){
            System.out.println("CompareA");
        }
    }

CompareB接口：默认方法method

public interface CompareB {
        public default void method(){
            System.out.println("CompareB");
        }
    }

实现类：必须重写，这个重写既看做是对CompareA的重写，也可以看做是对CompareB的重写

// 接口的实现类
    class SubClass implements CompareA,CompareB{
        // 必须重写，不重写就会使接口冲突，不知道调用哪个接口的method方法
        // 这个重写既是对CopmpareA的重写，也是对CompareB的重写
        @Override
        public void method() {
            System.out.println("SubClass");
        }
    }

**知识点4：**类优先原则，子类（实现类）继承了父类并实现了接口；父类和接口中声明了同名同参数的方法（其中接口中的是抽象方法），默认情况下，子类（实现类）在没有重写此方法的情况下，调用的是父类的方法，而不是接口中的方法

CompareA接口：method方法

package com.zl.cmp;
    
    public interface CompareA {
        public default void method(){
            System.out.println("interface");
        }
    }

SuperClass类：method方法

package com.zl.cmp;
    
    public class SuperClass {
        public void method(){
            System.out.println("class");
        }
    }

SubClass子类（实现类）

package com.zl.cmp;
    
    public class SubClass extends SuperClass implements CompareA{
        public static void main(String[] args) {
            SubClass subClass = new SubClass();
            subClass.method(); // class 优先访问类的
        }
    }

**知识点5：**如何在子类（或实现类）中调用父类或接口中被重写的方法

public void doSome(){
        // 调用自己类中的方法
        method();
        // 调用父类中的
        super.method();
        // 调用任意接口中的
        CompareA.super.method(); // 调用CompareA中的默认方法
        CompareB.super.method(); // 调用CompareB中的默认方法
    }

**在 JDK9.0 时，接口又增加了私有方法 ：**

**知识点6：**私有方法，把默认方法中相同的代码抽取出来

package com.zl.cmp;
    
    
    public interface CompareA {
       // 私有方法
        private void method(){
            System.out.println("interface");
        }
    
    }

#### 三：多线程 ####

（1）并行与并发

> **并行（parallel）：**指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻， 有多条指令在多个 CPU 上同时执行；比如：多个人同时做不同的事。

![e673f7a2577c442eb89cf304defd7852.png][]

生活中例子：

![01fa05858b194ac7aad4ddec312d7831.png][]

> **并发（concurrency）：**指两个或多个事件在同一个时间段内发生。即在一段时间内，有多条指令在单个 CPU 上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。

![a68f9e5ea0bf4acaa2e7eb2dcccd9a55.png][]

生活中例子：

![e7447163bd144f0abfb88801ff3d1146.png][]

> 在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时 交替运行的时间是非常短的。而在多核 CPU 系统中，则这些可以并发执行的程序便可以分配到多个 CPU 上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程 序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

（2）创建线程的四种方式

第一种：通过继承Thread类来**创建**并**启动多线程**的步骤如下：

> ①定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务；
> 
> ②创建Thread子类的实例，即创建了线程对象；
> 
> ③调用线程对象的start()方法来启动该线程；

第二种方式：实现Runnable接口

> ①定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体；
> 
> ②创建Runnable实现类的实例，并以此实例作为Thread的target参数来创建Thread对象，该Thread对象才是真正 的线程对象；
> 
> ③调用线程对象的start()方法，启动线程，调用Runnable接口实现类的run方法；

第三种方式：实现Callable接口

> ①定义Callable接口的实现类，并重写该接口的call()方法，相比run()方法，可以有返回值、方法可以抛出异常、支持泛型的返回值（需要借助FutureTask类，获取返回结果） ；
> 
> ②创建Callable接口实现类的对象，将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象；
> 
> ③将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()；

第四种方法：使用线程池（暂时作为了解）

现有问题：

> 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，即执行完一个任务，并不被销毁，而是可以继续执行其他的任务

思路：

> 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用；类似生活中的公共交通工具。

![061094f1804740809e4a185fdf35fe11.png][]

好处：

> 提高响应速度（减少了创建新线程的时间）
> 
> 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
> 
> 便于线程管理
> 
> – 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);
                }
            }
        }
    }
    
    class NumberThread2 implements Callable {
        @Override
        public Object call() throws Exception {
            int evenSum = 0;//记录偶数的和
            for(int i = 0;i <= 100;i++){
                if(i % 2 == 0){
                    evenSum += i;
                }
            }
            return evenSum;
        }
    
    }
    
    public class ThreadPoolTest {
    
        public static void main(String[] args) {
            //1. 提供指定线程数量的线程池
            ExecutorService service = Executors.newFixedThreadPool(10);
            ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
    //        //设置线程池的属性
    //        System.out.println(service.getClass());//ThreadPoolExecutor
            service1.setMaximumPoolSize(50); //设置线程池中线程数的上限
    
            //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
            service.execute(new NumberThread());//适合适用于Runnable
            service.execute(new NumberThread1());//适合适用于Runnable
    
            try {
                Future future = service.submit(new NumberThread2());//适合使用于Callable
                System.out.println("总和为：" + future.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
            //3.关闭连接池
            service.shutdown();
        }
    
    }

（3）Thread 类的常用结构

实现线程的方式中：继承Thread类和实现Runnable接口中，Thread 类实际上也是实现了 Runnable 接口的类！

构造器：

> ①public Thread() :分配一个新的线程对象。
> 
> ②public Thread(String name) :分配一个指定名字的新的线程对象。
> 
> ③public Thread(Runnable target) :指定创建线程的目标对象，它实现了 Runnable 接口 中的 run 方法
> 
> ④public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指 定名字。

常用方法1：

> ①public void run() ：此线程要执行的任务在此处定义代码。
> 
> ②public void start() ：导致此线程开始执行; Java 虚拟机调用此线程的 run 方法。
> 
> ③public String getName() ：获取当前线程名称。
> 
> ④public void setName(String name)：设置该线程名称。
> 
> ⑤public static Thread currentThread() ：返回对当前正在执行的线程对象的引用。在 Thread 子类中就是this，通常用于主线程和 Runnable 实现类
> 
> ⑥public static void sleep(long millis) ：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
> 
> ⑦public static void yield()：yield 只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了 yield 方法暂停之后，线程调度器又将其调度出来重新执行。

常用方法2：

> ①public final boolean isAlive()：测试线程是否处于活动状态，如果线程已经启动且尚未终止，则为活动状态。
> 
> ②void join() ：等待该线程终止。
> 
> void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒，如果 millis 时间 到，将不再等待。
> 
> void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
> 
> ③public final void stop()：已过时，不建议使用。强行结束一个线程的执行，直接进入 死亡状态。run()即刻停止，可能会导致一些清理性的工作得不到完成，如文件，数据 库等的关闭。同时，会立即释放该线程所持有的所有的锁，导致数据得不到同步的处 理，出现数据不一致的问题。
> 
> ④void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成 对出现，否则非常容易发生死锁。suspend()调用会导致线程暂停（挂起），但不会释放任何锁 资源，导致其它线程都无法访问被它占用的锁，直到调用 resume()。已过时，不建议 使用。

（4）多线程的生命周期

**JDK1.5 之前：5 种状态**

> 线程的生命周期有五种状态：**新建（New）、就绪（Runnable）、运行 （Running）、阻塞（Blocked）、死亡（Dead）。**CPU 需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

![c32c6ca11b154fdc882ec19492632f3d.png][]

**JDK1.5 及之后：6 种状态**

> Java官方API将线程的整个生命周期分为六个状态，分别是：**NEW(新建状态)、RUNNABLE(可运行状态)、BLOCKED(阻塞状态)、WAITING(无限等待状态)、TIMED\_WAITING(定时等待状态)和TERMINATED(终止状态)。**线程的不同状态表明了线程当前正在进行的活动，在程序中，通过一些操作，可以使线程在不同状态之间转换。

![975ecfbd4eb7461d822f0f56ae35909d.png][]

阻塞状态分为三种：BLOCKED（阻塞）、WAITING（无限等待）、TIMED\_WAITING（定时等待）。

> **BLOCKED（锁阻塞）：**在 API 中的介绍为：一个正在阻塞、等待一个监视器锁（锁对象）的线程处于这一状态，只有获得锁对象的线程才能有执行机会。例如：线程 A 与线程 B 代码中使用同一锁，如果线程 A 获取到锁，线程 A 进入到 Runnable 状态，那么线程 B 就进入到 Blocked 锁阻塞状态。
> 
> **TIMED\_WAITING（计时等待）：**在 API 中的介绍为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。 例如：当前线程执行过程中遇到 Thread 类的 sleep 或 join方法，Object 类 的 wait方法，LockSupport 类的 park 方法，并且在调用这些方法时，设置了时间，那么当前线程会进入 TIMED\_WAITING，直到时间 到，或被中断。
> 
> **WAITING（无限等待）：**在 API 中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。 例如：当前线程执行过程中遇到遇到 Object 类的 wait，Thread 类的join，LockSupport 类的 park 方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入 WAITING 状态，直到被唤醒。
> 
> – 通过 Object 类的 wait 进入 WAITING 状态的要有 Object 的 notify/notifyAll 唤醒；
> 
> – 通过 Condition 的 await 进入 WAITING 状态的要有 Condition 的 signal 方法唤醒；
> 
> – 通过 LockSupport 类的 park 方法进入 WAITING 状态的要有 LockSupport 类的 unpark 方法唤醒 ；
> 
> – 通过 Thread 类的 join 进入 WAITING 状态，只有调用 join 方法的线程对象结束才能让当前线程恢复；
> 
> **说明：**当从 WAITING 或 TIMED\_WAITING 恢复到 Runnable 状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入 BLOCKED 状态。

（5）线程安全问题及解决

**第一种解决方案：**同步机制 (synchronized)来解决线程安全问题，前面[http://t.csdn.cn/eUw30][http_t.csdn.cn_eUw30]已经赘述的很详细，这里就不在叙述。

> 同步代码块：
> 
> ①在实现Runnable接口的方式中，同步监视器（锁）是可以考虑使用this；
> 
> ②在继承Thread类的方式中，同步监听器（锁）要慎用this，可以考虑使用（类名.class）
> 
> 同步方法：
> 
> ①静态方法：默认是当前类的 Class 对象（类名.class） ，类锁（锁的是类，一个类一个锁）
> 
> ②非静态方法：默认就是this，（锁的是当前对象，一个对象一个锁）

**缺点**：synchronized在操作共享数据时，多线程其实是串行执行的，意味着性能低！

单例设计模式的线程安全问题

> ①饿汉式没有线程安全问题：在类初始化时就直接创建单例对象，而类初始化过程是没有线程安全问题的；
> 
> ②懒汉式线程安全问题 ：延迟创建对象，第一次调用 getInstance 方法再创建对象；

存在线程安全问题：

> ①模拟多线程并发，当一个线程去获取Person对象时，遇到Sleep睡眠；此时另外一个线程进行访问，上一个线程因为睡眠还没有创建出来Person对象，此时第二个线程也会进行创建Person对象，这就不是单例有线程安全的问题；
> 
> ②调用join方法，是让主线程进入阻塞，让分支线程先执行，防止主线程先执行之后程序就结束，导致分支线程赋不上值都为null；

package com.zl.pojo;
    
    
    public class Singleton {
    
        static Person p1;
        static Person p2;
        public static void main(String[] args) {
            // 多线程
            Thread t1 = new Thread(){
                @Override
                public void run() {
                    p1 = Person.getPerson();
                }
            };
    
            Thread t2 = new Thread(){
                @Override
                public void run() {
                    p2 = Person.getPerson();
                }
            };
    
            t1.start();
            t2.start();
    
            // 调用join方法
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(p1);
            System.out.println(p2);
            System.out.println(p1 == p2);
        }
    }
    
    class Person{
        private static Person person;
        private Person(){
        }
        // 饿汉方式
        public static Person getPerson(){
            if (person == null){
    
                try {
                    // 模拟延迟
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
    
                person = new Person();
            }
            return person;
        }
    
    }

解决线程安全问题：

// 第一种方法：在静态方法上添加
        public synchronized static Person getPerson(){ // 静态方法，默认锁的是当前类（Person.class）
            if (person == null){
                try {
                    // 模拟延迟
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
    
                person = new Person();
            }
            return person;
        }
    
        // 第二种方法：代码块上添加
        public static Person getPerson(){ // 静态方法，默认锁的是当前类（Person.class）
            synchronized (Person.class) {
                if (person == null){
                    try {
                        // 模拟延迟
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
    
                    person = new Person();
                }
            }
            return person;
        }

**第二种解决方案：**锁Lock

**关于死锁补充：**

诱发死锁的原因：

> ①互斥条件：一个线程握住这把锁，另一个线程就肯定握不住，互斥！
> 
> ②占用且等待：t1线程占用A锁，等待B锁的释放；t2线程握住B锁，等待A锁的释放！
> 
> ③不可抢夺（或不可抢占）：并且是无法抢夺的！
> 
> ④循环等待：最终造成循环等待

解决死锁： 死锁一旦出现，基本很难人为干预，只能尽量规避，可以考虑打破上面的诱发 条件。

> 针对条件 1：互斥条件基本上无法被破坏，因为线程需要通过互斥解决安全问题。
> 
> 针对条件 2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。
> 
> 针对条件 3：占用部分资源的线程在进一步申请其他资源时，如果申请不到， 就主动释放掉已经占用的资源。
> 
> 针对条件 4：可以将资源改为线性顺序；申请资源时，先申请序号较小的，这样避免循环等待问题。

**JDK5.0新特性：Lock(锁)**

> （1）JDK5.0的新增功能，保证线程的安全。与采用synchronized相比，Lock可提供多种锁方案，更灵活、更强大。Lock通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
> 
> （2）java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
> 
> （3）在实现线程安全的控制中，比较常用的是`ReentrantLock（可重入锁）`，可以显式加锁、释放锁。 ReentrantLock类实现了 Lock 接口，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。
> 
> （4）Lock锁也称同步锁，加锁与释放锁方法，如下：

public void lock() :加同步锁。
    public void unlock() :释放同步锁。

步骤：

①创建 Lock 的实例，必须确保多个线程共享同一个 Lock 实例；static修饰

②调动 lock()方法，实现需共享的代码的锁定；线程安全的代码放到try里面

③ 调用 unlock()，释放共享代码的锁定；为了保证解锁肯定执行，放到finally里面

package com.zl.pojo;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    
    public class Singleton {
    
        static Person p1;
        static Person p2;
    
        public static void main(String[] args) {
            // 多线程
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    p1 = Person.getPerson();
                }
            };
    
            Thread t2 = new Thread() {
                @Override
                public void run() {
                    p2 = Person.getPerson();
                }
            };
            // 启动线程
            t1.start();
            t2.start();
    
            // 调用join方法，是让主线程进入阻塞，让分支线程先执行，防止主线程先执行，导致分支线程赋不上值都为null
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(p1);
            System.out.println(p2);
            System.out.println(p1 == p2);
        }
    }
    
    class Person {
        private static Person person;
    
        // 静态的属性
        private static final ReentrantLock lock = new ReentrantLock();
    
        private Person() {
        }
    
        public static Person getPerson() { // 静态方法，默认锁的是当前类（Person.class）
    
            // 上锁
            lock.lock();
    
            try {
                if (person == null) {
                    try {
                        // 模拟延迟
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
    
                    person = new Person();
                }
                return person;
            } finally {
                // 解锁
                lock.unlock();
            }
        }
    }

**synchronized 与 Lock 的对比**

> ①Lock 是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized 是隐式锁，出了 作用域、遇到异常等自动解锁；
> 
> ②Lock 只有代码块锁，synchronized 有代码块锁和方法锁；
> 
> ③使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性 （提供更多的子类），更体现面向对象；
> 
> ④（了解）Lock 锁可以对读不加锁，对写加锁，synchronized 不可以 ；
> 
> ⑤（了解）Lock 锁可以有多种获取锁的方式，可以从 sleep 的线程中抢到锁， synchronized 不可以 ；

在开发建议中处理线程安全问题优先使用顺序为： Lock ----> 同步代码块 ----> 同步方法！

**线程间通信**

（1）为什么要处理线程间通信

> 当我们`需要多个线程`来共同完成一件任务，并且我们希望他们`有规律的执行`，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据！
> 
> 比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— **等待唤醒机制**

（2）等待唤醒机制

> 这是多个线程间的一种`协作机制`。谈到多线程我们经常想到的是线程间的`竞争（race）`，比如：去争夺锁，但是线程间也会有协作机制。
> 
> 在一个线程满足某个条件时，就进入等待状态（`wait() / wait(time)`）， 等待其他线程执行完他们的指定代码过后再将其唤醒（`notify()`）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 `notifyAll()`来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
> 
> ①wait：线程不再活动，不再参与调度，进入 `wait set` 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED\_WAITING。它还要等着别的线程执行一个`特别的动作`，也即“`通知（notify）`”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（`ready queue`）中
> 
> ②notify：则选取所通知对象的 wait set 中的一个线程释放；
> 
> ③notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

> ①如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；
> 
> ②否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态；

例题：使用两个线程打印 1-100；线程1, 线程2 交替打印

package com.zl.account;
    
    
    public class PrintNum {
        public static void main(String[] args) {
            MyRunnable r = new MyRunnable();
            Thread t1 = new Thread(r);
            Thread t2 = new Thread(r);
            t1.setName("t1");
            t2.setName("t2");
            t1.start();
            t2.start();
        }
    
    }
    
    class MyRunnable implements Runnable{
        private int i = 1;
        @Override
        public void run() {
            while (true){
                synchronized (this) { // 解决多线程问题
    
                    notify(); // 唤醒线程，省略了this
    
                    if (i<=100){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(Thread.currentThread().getName()+"--->"+i);
                        i++;
    
                        // 解决交替打印的问题
                        try {
                            wait(); // 进入等待状态，释放锁，省略了this
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
    
                    }else {
                        break;
                    }
                }
            }
        }
    }

调用wait和notify需注意的细节

> ①wait方法与notify方法必须要由`同一个锁对象调用`。因为对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
> 
> ②wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
> 
> ③wait方法与notify方法必须要在`同步代码块`或者是`同步函数`中使用（出现在synchronized中）。因为：必须要`通过锁对象`调用这2个方法（使用的是同步监听器中的对象去调用的这两个方法，所以synchronized、wait、notify三者必须使用的是同一个对象）。否则会报java.lang.IllegalMonitorStateException异常。

面试题：区分 sleep()和 wait()

> 相同点：一旦执行，都会使得当前线程进入阻塞状态！
> 
> 不同点：
> 
> ① 定义方法所属的类：sleep()方法是Thread 中定义。 wait()方法是Object 中定义
> 
> ② 使用范围的不同：sleep()方法可以在任何需要使用的位置被调用； wait()方法必须使 用在同步代码块或同步方法中
> 
> ③ 都在同步结构中使用的时候，是否释放同步监视器的操作不同：sleep()方法不会释放同步监视器 ；wait()方法会释放同步监视器
> 
> ④ 结束等待的方式不同：sleep()方法指定时间一到就结束阻塞。 wait()方法可以指定时间也可以无限等待直到 notify 或 notifyAll。

[e673f7a2577c442eb89cf304defd7852.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b8bb23194de04602bb362f8c3058b504.png
[01fa05858b194ac7aad4ddec312d7831.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/31e3e91d87204512944e01adb9f37adf.png
[a68f9e5ea0bf4acaa2e7eb2dcccd9a55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e9d941609f9046298d7333f55593856f.png
[e7447163bd144f0abfb88801ff3d1146.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4e91eb38e7544361a4b97d3145e25a35.png
[061094f1804740809e4a185fdf35fe11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6afbdf4587994b2db6a3f0ef041858e6.png
[c32c6ca11b154fdc882ec19492632f3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bf9a963b7b7543bf9274693a729be62f.png
[975ecfbd4eb7461d822f0f56ae35909d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/161fdc38e17e4dee97ddc2981ccc37a7.png
[http_t.csdn.cn_eUw30]: http://t.csdn.cn/eUw30