【Java多线程】关于多线程的一些案例 —— 单例模式中的饿汉模式和懒汉模式以及阻塞队列

向右看齐 2024-04-20 11:58 10阅读 0赞

**目录**

1、单例模式

1.1、饿汉模式

2.1、懒汉模式

2、阻塞队列

2.1、BlockingQueue 阻塞队列数据结构

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

![6374235f8688435d82bd663bba273aa7.gif][]

## 1、单例模式 ##

对框架和设计模式的简单理解就是，这两者都是“大佬”设计出来的，让即使是一个代码写的不太好的“菜鸡程序员”也能写出还可以的代码。**设计模式也可以认为是对编程语言语法的补充**。此处提到的“单例模式”就是一种设计模式。

> **框架**（硬性的规定）
> 
> **设计模式**（软性的规定）遵循设计模式，代码的下限就被兜住了，类似下棋时的“棋谱”。

单例，顾名思义，单个实例（对象）。**某个类**，在一个进程中，只应该创建出一个实例（原则上不应该有多个）。使用单例模式，就可以对代码进行一个更严格的校验和检查。

### 1.1、饿汉模式 ###

饿汉模式的“创建时机”非常早，实例在类加载的时候就被创建了，相当于程序一启动实例就创建了。**因此使用“饿汉”来形容实例创建的迫切，非常早。【并且由于只涉及到读操作，天然的线程安全。】**

package thread;
    
    // 期望这个类只能有唯一的实例 (一个进程中)
    class Singleton {
        private static Singleton instance = new Singleton();//static修饰的类对象，只存在一个
    
        public static Singleton getInstance() {   //只提供一个方法获取静态（类属性）实例
            return instance;   //只涉及到读操作，天然的线程安全
        }
    
        private Singleton() {}   //使用private修饰构造方法，使得无法使用new创建实例
    }
    
    public class ThreadDemo26 {
        public static void main(String[] args) {
            // Singleton s = new Singleton();   //无法new
            Singleton s = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();
            System.out.println(s == s2);   //true
        }
    }

> 在代码中，使用static修饰了一个类对象，然后提供一个方法来获得这个对象，再使用 private 修饰构造方法，使得无法通过 new 创建实例。，由于该实例使用了 static 修饰，在类加载时就已经存在，所以就是懒汉模式。

### 2.1、懒汉模式 ###

懒汉模式的实例创建时机相比于饿汉模式要更晚，直到第一次使用的时候，才会创建实例。相比“饿汉模式”，“懒汉模式”效率更高。

> **举个例子：**
> 
> 有一个编辑器想要打开一个10GB的文件，如果按照**“饿汉”**的方式，编辑器就会先把10GB的数据都加载到内存中，然后再进行统一展示；
> 
> 如果按照**“懒汉”**的方式，编辑器就会只读取一小部分数据（比如只读10KB），把10KB先展示出来，随着用户进行翻页等操作，再继续读取后续的数据。

package thread;
    
    // 懒汉的方式实现单例模式.
    class SingletonLazy {
        // 这个引用指向唯一实例. 这个引用先初始化为 null, 而不是立即创建实例
        private volatile static SingletonLazy instance = null;   //volatile禁止重排序
        private static Object locker = new Object();
    
        public static SingletonLazy getInstance() {  //将创建实例的操作放到了getInstance里
            if (instance == null) {   //【注意理解此处的两个if】
                synchronized (locker) {    //考虑线程安全，需要加锁
                    if (instance == null) {   //【注意理解此处的两个if】
                        instance = new SingletonLazy();
                    }
                }
            }
            return instance;
        }
    
        private SingletonLazy() { }
    }
    
    public class ThreadDemo27 {
        public static void main(String[] args) {
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            System.out.println(s1 == s2);   //true
        }
    }

> 如果 Instance 为 null, 就说明是首次调用, 首次调用就需要考虑线程安全问题, 就要加锁。
> 
> 如果非 null, 就说明是后续的调用, 就不必加锁了。
> 
> --------------------
> 
> **讲解第10行和第12行的 if 语句：（双重校验锁）**
> 
> 这样相同且连续的 if 代码从来没写过，这是因为之前写的代码都是在**单线程却无阻塞**的情况，这种情况下**连续两个相同的 if 是无意义**的；
> 
> 但是涉及到**阻塞以及多线程**的情况，这样的代码就**非常的有意义**了。看上去是两个一样的条件，实际上这两个条件的结果可能是相反的。
> 
> 第一个 if 判定的是**是否要加锁**，如果不是首次调用时就跳过加锁环节，因为此时已经有对象了不需要再创建对象，直接返回即可。
> 
> 第二个 if 判定的是**是否要创建对象**。
> 
> --------------------
> 
> **讲解第6行：（volatile 禁止代码重排序）**
> 
> **讲解第13行：（此处的new 操作又可拆成三个大的步骤，而这三个步骤可能会发生代码重排序。比如步骤1 2 3 =》 1 3 2 ，为了防止这种情况，使用了 volatile）**
> 
> 1、申请一段内存空间
> 
> 2、在这个内存上调用构造方法，创建出这个实例
> 
> 3、把这个内存地址赋值给 Instance 引用变量

## 2、阻塞队列 ##

阻塞队列（BlockingQueue），顾名思义，就是一个队列。阻塞队列是基于普通队列做出的扩展。

**基于阻塞队列实现的服务器程序叫****消息队列（message queue，mq）**

> **阻塞队列的特点有以下两点：**
> 
> 1、线程安全
> 
> 2、具有阻塞特性
> 
> a）如果针对一个已经**满了**的队列进行**入队列**，此时**入队列**操作就会阻塞，一直阻塞到队列**不满**（其他线程**出队列**元素）之后。
> 
> b）如果针对一个已经**空了**的队列进行**出队列**，此时**出队列**操作就会阻塞，一直阻塞到队列**不空**（其他线程**入队列**元素）之后。

基于阻塞队列，就可以实现**“生产者消费者模型”。**

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

![b4a88834d6e24f07bab5256db306688f.png][]

2、**削峰填谷**，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。**【类似于现实中三峡大坝所承担的作用】**

![5b145b4a0c7849df91c121a0c1add340.png][]

类似于擀饺子皮和包饺子的过程，擀饺子皮的线程就是生产者，包饺子的线程是消费者，饺子皮擀好之后放到桌子上，包饺子的线程在从桌子上拿饺子皮包饺子。这里的桌子就是起到了“阻塞队列”的效果，由于桌子的存在，擀饺子皮的线程擀的速度快时，可以把多的饺子皮放到桌子上先（而不需要直接递给包饺子的线程）。

### 2.1、BlockingQueue 阻塞队列数据结构 ###

**Java标准库中提供了现成的阻塞队列数据结构 BlockingQueue，**另外还有 ArrayBlockingQueue，LinkedBlockingQueue，PriorityBlockingQueue

package thread;
    
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    
    public class ThreadDemo28 {
        public static void main(String[] args) throws InterruptedException {
            BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
            queue.put("aaa");
            String elem = queue.take();
            System.out.println("elem = " + elem);
            elem = queue.take();   //进入阻塞状态
            System.out.println("elem = " + elem);
        }
    }

> 注意：此处的阻塞队列，入队出队操作不再是以前的 offer 和 poll 方法，而是使用**带有阻塞功能**的 **put 和 take** 方法。

![e74b9689aa3a4a7db338f1cb31effb0e.gif][]

[【网络原理】TCP 协议中比较重要的一些特性（二）-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136579333?spm=1001.2014.3001.5501][TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136579333_spm_1001.2014.3001.5501][【网络原理】TCP 协议中比较重要的一些特性（一）-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136366463?spm=1001.2014.3001.5501][TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136366463_spm_1001.2014.3001.5501][JVM 的垃圾回收机制以及垃圾回收算法的详解-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136530845?spm=1001.2014.3001.5501][JVM _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136530845_spm_1001.2014.3001.5501]

**如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！**

[6374235f8688435d82bd663bba273aa7.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/0eae968121884998960628d10a14864a.gif
[b4a88834d6e24f07bab5256db306688f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/846c9be9b9824c73aade866336337715.png
[5b145b4a0c7849df91c121a0c1add340.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/c947db9b23eb4548992d1e07f330bc85.png
[e74b9689aa3a4a7db338f1cb31effb0e.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a38ab48d42cc485ca45bf9b29a79b2ff.gif
[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136579333_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136579333?spm=1001.2014.3001.5501
[TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136366463_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136366463?spm=1001.2014.3001.5501
[JVM _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136530845_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136530845?spm=1001.2014.3001.5501