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

目录

一：单例模式

二：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 上同时执行；比如：多个人同时做不同的事。

生活中例子：

 

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

 

 生活中例子：

 

在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 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()；

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

现有问题：

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

思路：

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

 

好处：

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中线程，不需要每次都创建）

便于线程管理

– 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 需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

JDK1.5 及之后：6 种状态

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

 

阻塞状态分为三种：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已经赘述的很详细，这里就不在叙述。

同步代码块：

①在实现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。