一、单例模式

单例模式属于最容易被问到的一种设计模式。

啥是设计模式？ 类似于棋谱，按摩模式写代码，可以更加规范。

单例模式的含义：

单例：单个实例对象 某个类有且只有一个对象。

这一点在很多场景上都需要. 比如 JDBC 中的 DataSource 实例就只需要一个.

单例模式分为“饿汗”和“懒汉”两种模式。

1.1饿汗模式

public class Singleton {
    //这个singleton就是这个类的唯一实例,饿汗模式是直接创建的
    private  static Singleton singleton = new Singleton();

    //约定好,类外部使用Singleton实例,就使用getInstance方法才能拿到
    public Singleton getInstance() {
        return singleton;
    }

    //将 构造方法设为private,此时在其他类中就不能new Singleton这个类实例了
    private Singleton() {

    }
}

重点关注：

1、将构造方法私有化这个操作禁止了其他类中new singleton实例

2、singleton这个变量也被我们用private私有化，防止用户获取

3、如果想要使用这个类，唯一的入口就是使用getInstance方法。

这样就可以保证当前的Singleton是单例的

为什么叫他饿汗模式？

类加载阶段就创建实例，创建实例的时间非常早，非常急迫

1.2懒汉模式

先说结论：懒汉模式效率比饿汗模式高。

初版懒汉模式：

public class SingletonLazy {
    private  static SingletonLazy singleton = null;

    //真正创建实例的时间点,第一次调用getInstance方法的时候才会触发
    //后续调用getInstance就立即返回
    public SingletonLazy getInstance() {
        if(singleton == null) {
            singleton = new SingletonLazy();
        }
        return singleton;
    }
	//将 构造方法设为private,此时在其他类中就不能new Singleton这个类实例了
    private SingletonLazy() {

    }
}

优点：

private static SingletonLazy singleton = null;

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

2、即使后面有代码调用getInstance方法，但是调用的时机比较晚，这个时候创建实例的时机也就迟了，就和其他耗时操作岔开来了。

注意：一个程序刚启动时候要初始化的东西很多，系统资源紧张，这个时候能节约一点都非常好，所以懒汉模式是当我们需要用的时候再去创建。

懒汉模式中关于多线程安全的问题

接下来问题就来了，这可是多线程案例，现在哪里和多线程有关系？

想一个问题，当多个线程使用上述代码版本的饿汗模式和懒汉模式时候，哪个线程安全，哪个线程不安全？

前面提到过，多个线程同时修改一个变量是会不安全的；

饿汗模式都没有涉及到修改，只涉及到了读操作。

懒汉模式的上述代码版本即涉及读数据，又涉及到修改。

如果两个线程同时都是第一次调用getInstance时候就有可能出现两个线程创建了两个不同的实例，这是和我们单例模式的思想是违背的，是有问题的。流程图如下：

解决办法：加锁，让创建实例的操作变成原子的操作。

线程安全的懒汉模式代码-版本1

public class SingletonLazy {
    private  static SingletonLazy singleton = null;

    //真正创建实例的时间点,第一次调用getInstance方法的时候才会触发
    //后续调用getInstance就立即返回
    public SingletonLazy getInstance() {
        //加锁 
        synchronized(SingletonLazy.class) {
            if(singleton == null) {
                singleton = new SingletonLazy();
            }
        }
        return singleton;
    }

    private SingletonLazy() {

    }
}

此时就可以解决线程安全的问题。

但是这里隐藏了第二个问题：线程安全也不是一直都不安全，只是实例创建之前不安全，当实例创建完以后剩下以后使用getInstance方法都是安全的，没有必要每次都去竞争锁，加锁设计到了用户态到内核态之间的切换，切换成本特别高，所以我们要想办法避免无脑加锁。

线程安全的懒汉模式代码-版本2

public class SingletonLazy {
    private  static SingletonLazy singleton = null;

    //真正创建实例的时间点,第一次调用getInstance方法的时候才会触发
    //后续调用getInstance就立即返回
    public SingletonLazy getInstance() {
        //第一层if判断是否要加锁
        if(singleton == null) {
            synchronized(SingletonLazy.class) {
                //第二层if判断是否要创建实例
                if(singleton == null) {
                    singleton = new SingletonLazy();
                }
            }
        }
        return singleton;
    }

    private SingletonLazy() {

    }
}

这两个if条件一模一样，但是不代表第一个if成立第二个if也成立，加锁以后发生的事情谁也不知道，当下次再回到这个线程进入第二个if时候可能实例已经创建好了，不需要去NEW了。

线程安全的懒汉模式代码-最终版

指令重排序带来的线程安全问题

new 操作本质上也是分成三个步骤

1.申请内存,得到内存首地址
2.调用构造方法,来初始化实例
3.把内存的首地址赋值给 singleton 引用

这个场景可能编译器会进行指令重排序的优化：

1.申请内存,得到内存首地址
2.(原来的3)把内存的首地址赋值给 singleton 引用
3.(原来的2)调用构造方法,来初始化实例

这种指令顺序只执行1,2步骤的话是会得到不完全对象,只是有内存,但是没初始化,所以内存上的数据无效。

在单线程角度下这样的指令重排序的优化是没有问题的

但是在多线程角度下就会有问题，假设当t1线程因为指令重排序的原因new操作时候刚执行到第二个步骤，此时t2线程就急急忙忙认为singleton已经分配了内存，但其实这部分内存是无效的，t2线程急急忙忙去使用，就会出现问题。

解决方法：禁止指令重排序；

使用volatile不仅可以保证内存可见性，还可以保证指令重排序

单例模式其实要正真的安全，还要使用枚举来实现，具体感兴趣可以自行了解~

【单例模式面试题】

1、synchronized加哪，作用？

加在第一层if后面，作用就是确保这个单例模式只有一个实例对象，而不会 在多线程情况下创建多个实例对象。

2、双层if的每个if含义 第一层if判断是否要加锁，第二层if判断是否要创建实例对象

3、volatile在单例模式的作用 防止指令重排序

二、阻塞队列

我们学习过队列（Queue），它的特点是先进先出。

但是并不是所有队列都是先进先出的，比如说我们学习过的PriorityQueue优先级队列、消息队列等。

1.什么是阻塞队列？

阻塞队列是一个特殊队列，它是先进先出的，区别于普通队列的优点：

1、线程安全的

2、带有阻塞功能

a) 如果队列满,继续入队列,入队列操作就会阻塞,知道队列不满,入队列才能完成。
b)如果队列空，继续出队列，出队列操作也会阻塞，知道队列不为空，出队列才能完成。

阻塞队列应用场景：生产者消费者模型。

2.应用场景：生产者消费者模型

生产者消费者模型（ 典型开发模型.）：描述的是多线程协同工作的一种方式。

【生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题】

举例说明：

1、有一台饮水机，而且只有一个出水口，现在有一群人要喝水，如果让这几个人都刚刚运动完特别渴准备自己去装水，他们有可能争抢起来，都想第一个喝到水，这些人就会频繁的竞争，导致严重的锁冲突。

2、假设我们饮水机前面有一个桌子，A在饮水机旁边负责接水然后放在桌子上面，B,C,D他们就去桌子旁边喝接好的水就好。【常见的模型】

【A就相当于生产者，B,C,D属于消费者，桌子相当于“交易场所”】

这个模型很好的解决了上诉锁冲突的问题。

解释：生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取.

生产者消费者模型/阻塞队列的作用：

1）使用阻塞队列，有利与“解耦合”

写A的代码的时候要知道B服务器的存在，写B的代码的时候也要知道A服务器的存在

此时加入一个C服务器，想要和A服务器交流，就势必要修改A中的代码。

如果使用阻塞队列的话就可以实现解耦合：

A和队列交互，B,C也和队列交互，这样他们就不用知道彼此的存在了。

2）削峰填谷

阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力.

如果不使用生产者消费者模型的写法，AB服务器直接交流时候，可能A服务器收到的业务特别多，他要发给B服务器，问题是太多了，A服务器处理不过来，但是A服务器它只知道它要发给B服务器，疯狂塞给B服务器，可能会导致AB服务器都挂掉。也就是说外面过来的流量会压到每个服务器中。

使用了生产者消费者模型：当流量骤增的时候，只有A服务器和阻塞队列承受了压力，即使A服务器挂了，B和C服务器还是按照自己能消化的能力从阻塞队列里面取任务，对B,C服务器影响就不大~

3.标准库的阻塞队列

在 Java 标准库中内置了阻塞队列：BlockingQueue

实现该接口具体的类：

LinkedBlockingQueue以及ArrayBlockingQueue

阻塞队列提供带有阻塞功能的方法【入队列，出队列】：

入队列：put() 【注意：offer()是不带有阻塞功能】

出队列：take()

需要注意的是阻塞队列没有提供普通队列里面获取首元素的方法。

阻塞队列的简单使用：

public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue();
        Thread customer = new Thread(()-> {
           while(true) {
               //取元素
               try {
                   int val = queue.take();
                   System.out.println("消费元素:" + val);
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        Thread producer = new Thread(() ->{
            Random random = new Random();
            while(true) {
                //存元素
                try {
                    int val =  random.nextInt(1000);
                     queue.put(val);
                    System.out.println("生产元素: " + val);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        customer.start();
        producer.start();

        customer.join();
        producer.join();
    }

4、模拟阻塞队列

通过“循环队列”的方式模拟

1、实现普通队列

public class MyBlockingQueue {
    private int[] arr = new int[10];
    private int head = 0;//记录队首元素下标
    private int tail = 0;//记录队尾元素下标
    private int size = 0;//记录当前队列元素个数

    //put操作
    public void put(int val) {
        //判断队列是否为满
        if(size == arr.length) {
            return;
        }

        arr[tail] = val;
        tail++;
        //循环队列
        //判断tail位置是否超出数组长度 越界的话tail指向0下标 新一轮循环
        if(tail >= arr.length) {
            tail = 0;
        }
        size++;
    }

    //take操作
    public int take() {
        //判断队列里面有没有元素
        if(size == 0) {
            return -1;
        }
        int val = arr[head];
        head++;
        //循环队列
        //判断head位置是否超出数组长度 越界的话head指向0下标 新一轮循环
        if(head == arr.length) {
            head = 0;
        }
        size--;
        return val;
    }
}

2、实现线程安全的循环队列

我们刚才实现的put和take方法的几乎每一行代码都涉及到读写操作，所以在多线程环境下，这种非原子操作一定是不安全的，我们需要对这两个方法进行加锁，并用volatile修饰相应的变量，来保证线程安全：

public class MyBlockingQueue {
    private int[] arr = new int[10];
    private volatile int head = 0;//记录队首元素下标
    private volatile int tail = 0;//记录队尾元素下标
    private volatile int size = 0;//记录当前队列元素个数

    //put操作
    public void put(int val) {
        synchronized (this) {
            //判断队列是否为满
            if(size == arr.length) {
                return;
            }
        
            arr[tail] = val;
            tail++;
            //循环队列
            //判断tail位置是否超出数组长度 越界的话tail指向0下标 新一轮循环
            if(tail >= arr.length) {
                tail = 0;
            }
            size++;
        }
    }

    //take操作
    public int take() {
        synchronized (this) {
            //判断队列里面有没有元素
            if(size == 0) {
                return -1;
            }
            int val = arr[head];
            head++;
            //循环队列
            //判断head位置是否超出数组长度 越界的话head指向0下标 新一轮循环
            if(head == arr.length) {
                head = 0;
            }
            size--;
            return val;
        }
    }
}

需要注意的是锁对象一定要相同，不然的话没有锁竞争相当于没有锁。

3、实现阻塞功能的循环队列

加入wait和notify功能

public class MyBlockingQueue {
    private int[] arr = new int[10];
    private volatile int head = 0;//记录队首元素下标
    private volatile int tail = 0;//记录队尾元素下标
    private volatile int size = 0;//记录当前队列元素个数

    //put操作
    public void put(int val) throws InterruptedException {
        synchronized (this) {
            //判断队列是否为满，满了就wait等待
            if(size == arr.length) {
                this.wait();
            }

            arr[tail] = val;
            tail++;
            //循环队列
            //判断tail位置是否超出数组长度 越界的话tail指向0下标 新一轮循环
            if(tail >= arr.length) {
                tail = 0;
            }
            size++;
			//唤醒另外一个线程(如果在wait中)
            this.notify();
        }
    }

    //take操作
    public int take() throws InterruptedException {
        synchronized (this) {
            //判断队列里面有没有元素,没有元素就wait等待
            if(size == 0) {
                this.wait();
            }
            int val = arr[head];
            head++;
            //循环队列
            //判断head位置是否超出数组长度 越界的话head指向0下标 新一轮循环
            if(head == arr.length) {
                head = 0;
            }
            size--;
            //唤醒另外一个线程(如果在wait中)
            this.notify();
            return val;
        }
    }
}

优化:

wait地方还有可能有问题,如果wait被唤醒后发现队列还是空或满的状态，那么继续执行代码仍然会出错，比如通过interrupt方法唤醒等待中的线程…

前面讲过interrupt可以直接唤醒正在sleep/wait/join的线程。

1、

if(size == arr.length) {
   this.wait();
}
//改为
while(size == arr.length) {
   this.wait();
}

2、

if(size == 0) {
   this.wait();
}
//改为:
while(size == 0) {
   this.wait();
}

以下代码就是模拟的代码全貌:

public class MyBlockingQueue {
    private int[] arr = new int[10];
    private volatile int head = 0;//记录队首元素下标
    private volatile int tail = 0;//记录队尾元素下标
    private volatile int size = 0;//记录当前队列元素个数

    //put操作
    public void put(int val) throws InterruptedException {
        synchronized (this) {
            //判断队列是否为满
            while(size == arr.length) {
                System.out.println("元素太多了,阻塞一下");
                this.wait();
            }

            arr[tail] = val;
            tail++;
            //循环队列
            //判断tail位置是否超出数组长度 越界的话tail指向0下标 新一轮循环
            if(tail >= arr.length) {
                tail = 0;
            }
            size++;

            this.notify();
        }
    }

    //take操作
    public int take() throws InterruptedException {
        synchronized (this) {
            //判断队列里面有没有元素
            while(size == 0) {
                System.out.println("开始阻塞");
                this.wait();
            }
            int val = arr[head];
            head++;
            //循环队列
            //判断head位置是否超出数组长度 越界的话head指向0下标 新一轮循环
            if(head == arr.length) {
                head = 0;
            }
            size--;
            this.notify();
            return val;
        }
    }
}