多线程（【多线程案例】单例模式+阻塞式队列+定时器+线程池）

目录

1. 单例模式（Singleton）

1.1 饿汉模式（比较急）

1.2 懒汉模式（不着急）

2. 阻塞式队列（BlockingQueue）

2.1 阻塞式队列与生产者消费者模型

2.2 标准库中的阻塞式队列

3.1 使用标准库中的定时器

4. 线程池（ExecutorService）

4.3 标准库中ThreadPoolExecuter构造方法（*）

4.4 线程池的执行流程和拒绝策略

4.5 线程池优点总结（*）

多线程案例

1. 单例模式（Singleton）

单例模式，是一种常见的设计模式，类似于“棋谱”（把在下棋过程中常见的情况，总结出来，可以让其他人看，棋谱就是一种比较“定式”的东西），也就是出现什么情况，我应该按照这个“棋谱”怎么去应对。

而在代码编程这里，也有总结出来的“棋谱”，也就是”设计模式”，这大大提高了程序员代码编程的下限。

单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例.

1.1 饿汉模式（比较急）

类加载阶段创建实例，创建实例的时机是非常早的，非常迫切的

这种就叫“饿汉模式”

class Singleton {
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
    //把构造方法设置为private，此时在类外面，就无法继续new实例了
    private Singleton() {

    }
}
public class Demo01 {
    public static void main(String[] args) {
        //强制保证当前Singleton是“单例”了
        Singleton instance = Singleton.getInstance();
    }
}

 

1.2 懒汉模式（不着急）

类加载阶段创建实例，创建实例比“饿汉模式”更迟”，带来的效率更高

懒汉模式是线程不安全的

如果整个代码后续没有调用getInstance，这样就把构造实例的过程给节省下来了

效率也就提升了 ，或者即使代码后续调用getInstance，但是调用的时机比较晚，这个时候创建实例的时机也就迟了，就和其他耗时操作岔开了，效率也能提高（一般程序刚启动时，要初始化的东西很多，系统资源紧张）

class SingletonLazy {
    private static SingletonLazy instance = null;
    
    public static SingletonLazy getInstance() {
        if(instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
    private SingletonLazy() {
        
    }
}
public class Demo02 {
    SingletonLazy instance = SingletonLazy.getInstance();
    
}

 

下面对比一下，前面的懒汉和饿汉模式的线程安全问题

1.3 懒汉模式（加锁）

前面已经说过了，懒汉模式线程不安全，那么如何修改让线程安全？

要想线程安全就要“加锁”，但加锁不是随便加的，而且加锁开销代价也比较大，所以可以

在实例没有创建之前，因为线程是不安全的，需要加锁

在实例创建之后，线程是安全的，就不需要加

因此，在加锁的外面，再加上一层判定条件，来判断实例是否创建了

class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if(instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
    private SingletonLazy() {
    }
}
public class Demo02 {
    SingletonLazy instance = SingletonLazy.getInstance();
}

 

假设两个线程同时getInstance，第一个线程拿到锁了，进入到第二层if，开始new对象了

new操作的本质是三步走

（1）申请内存，得到内存首地址

（2&