单例模式-＞饿汉模式-＞懒汉模式-＞阻塞队列-＞模拟实现阻塞队列-＞生产者消费者模型

单例模式->是一种固定套路,类似于"棋谱",按照套路来,可以避免一些问题

单例模式的特点->能够保证在某个类中只存在一个实例,不会创建多个实例

饿汉模式(线程安全):最基础的单例模式,类加载的同时就会创建实例,是线程安全的

java 复制代码

public class Singleton {
    // 在类加载时就完成了实例化，避免了线程同步的问题
    private static Singleton instance = new Singleton();

    private Singleton() {}// 私有构造函数，防止被外部实例化

    public static Singleton getInstance() {// 获取单例对象的静态方法
        return instance;
    }
}

懒汉模式 (线程不安全):类加载的时候不会创建实例,第一次使用的时候才创建实例,线程不安全

java 复制代码

public class SingleLaze {
    private static volatile SingleLaze instance = null;

    private SingleLaze() {} // 私有构造函数，防止外部实例化

    public static SingleLaze getInstance() {
        if (instance == null) { //首次调用get方法instance==null才会创建实例
             instance = new SingleLaze();           
        }
        return instance;
    }
}

懒汉模式(线程安全版)

两个懒汉模式横向对比可以发现,修改后的加上了锁和双重if判定以及给instance加上lvolatile

加锁/解锁在懒汉模式只会发生在第一次创建实例的时候,后面使用的时候就不需要加锁
外层的if是判断当前是否已有实例对象
内层if是判定是否需要创建对象,由于第一个if语句和第二个if语句之间因为synchronized发生的阻塞过程中,期间可能instance被其他线程创建了实例,所以双重判定在多线程/阻塞中很有必要
volatile修饰instance确保多线程情况下的内存可见性和禁止指令重排序

java 复制代码

public class SingleLaze {
    private static volatile SingleLaze instance = null;

    private SingleLaze() {} // 私有构造函数，防止外部实例化

    public static SingleLaze getInstance() {
        if (instance == null) { // 第一次检查，避免已有实例对象,再次创建新的对象情况

            synchronized (SingleLaze.class) { // 使用类对象作为锁,里面表示了singlelaze这个类

                if (instance == null) { // 第二次检查，确保单例

                    instance = new SingleLaze();
                }
            }
        }
        return instance;
    }
}

阻塞队列是什么?

阻塞队列是一种线程安全的数据结构,并具有以下特性

当队列空的时候,出队列操作就会阻塞,直到有元素入队列

当队列满的时候,入队列操作就会阻塞,直到有元素出队列

为什么要用阻塞队列?

在包饺子的场景中,如果不用阻塞队列,擀饺子皮的一直擀,但是包饺子的包的很慢,会出现饺子皮摆不下桌子的情况,如果用到阻塞队列,擀的人快,在桌子摆不下的情况就会阻塞等待,直到桌子能摆的下再擀,而包饺子快的情况下,就会等有饺子皮再包

标准库中阻塞队列BlockingQueue

java 复制代码

BlockingQueue<String> queue=new ArrayBlockingQueue<String>(1000);
//创建新的阻塞队列,元素类型string,元素个数1000
        
queue.put("abc");//put阻塞式入队列
// 需要throws声明可能会抛出异常
        
String elem=queue.take();//阻塞式出队列
//elem元素

模拟实现阻塞队列

使用循环队列的方式来实现
put插入元素的时候,判定如果队列满了,就进行wait(需要注意要循环进行wait,可能在被唤醒的时候队列依旧是满的)
take取出元素的时候,判定如果队列为空,就进行wait(也需要循环wait,确保线程在唤醒后能够再次检查等待条件，从而避免虚假唤醒等问题)
唤醒需要注意逻辑问题,wait是在满了或者空了的情况下才会运行,并且数据不可能是又满又空的状态,所以一次只会唤醒一个wait,两个wait不会同时运行,只有put下面的notify才能唤醒take上的wait,同理也只有take下面的notify才能唤醒put的wait
注意while和读写操作都要上锁,并且是一把锁才有用

代码实现

java 复制代码

public class MyBlockingQueue1 {
    //为了简单,不写作泛型,只考虑元素类型是string
    private String[]elems=null;
    private int head=0;//指向头结点下标
    private int tail=0;//指向尾节点下标
    private int size=0;//当前数组所存的元素个数

    //准备锁对象
    private Object locker =new Object();

    public MyBlockingQueue1(int capacity){//使用构造函数指定阻塞队列的最大容量
        elems=new String[capacity];
    }

    public void put(String elem) throws InterruptedException {
        synchronized (locker){
            while (size>=elems.length){
                locker.wait();//当前所占容量等于或超过最大容量,就阻塞等待
            }
            //没满
            elems[tail++]=elem;//将传入的元素从尾节点插入到数组,同时尾节点++
            if(tail>= elems.length){
                tail=0;
            }
            size++;//元素个数++

            //入队成功后唤醒可能在take时候阻塞的wait
            locker.notify();

        }
    }

    public String take() throws InterruptedException {
        String elem=null;//在锁里面创建对象就在锁外面返回不了
        synchronized (locker){
            while (size==0){
                locker.wait();//当前数组元素为0,就阻塞等待
            }
            //没空
            elem=elems[head++];
            if(head>= elems.length){
                head=0;
            }
            size--;//元素个数++

            //入队成功后唤醒可能在take时候阻塞的wait
            locker.notify();
        }
        return elem;
    }

    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue1 queue=new MyBlockingQueue1(1000);
        queue.put("aaa");
        queue.put("bbb");
        queue.put("ccc");
        queue.put("ddd");

        String elem= queue.take();
        System.out.println("elem="+elem);
         elem= queue.take();
        System.out.println("elem="+elem);
         elem= queue.take();
        System.out.println("elem="+elem);
         elem= queue.take();
        System.out.println("elem="+elem);
    }
}

运行结果

使用模拟实现的阻塞队列实现生产者消费者模型

只需要更改主函数内容

java 复制代码

public static void main(String[] args)  {
        MyBlockingQueue1 queue=new MyBlockingQueue1(1000);

        //生产者
        Thread t1=new Thread(()->{
            int n=1;
            while (true){
                try {
                    queue.put(n+"");
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产元素"+n);
                n++;
            }
        });

        //消费者
        Thread t2=new Thread(()->{
           while (true){
               try {
                   String n= queue.take();
                   System.out.println("消费元素"+n);
               //    Thread.sleep(500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });

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

如果在生产后加上延时,消费后不加延时,就会出现生产一个消费一个的情况

如果在消费后面加上延时而生产后面不加延时,就会出现生产了1000多个才开始消费第一个的情况