单例模式（饿汉方式，懒汉方式），阻塞队列

最新推荐文章于 2022-04-08 15:18:38 发布
最新推荐文章于 2022-04-08 15:18:38 发布
阅读量120 收藏
点赞数
分类专栏： Java 文章标签： java 多线程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51392818/article/details/117369282
版权

单例模式的作用

单例模式：全局唯一并且所有程序都可以使用的对象，就是单例模式。

单例模式的两种实现方式：

  1. 饿汉方式（线程安全的）
  2. 懒汉方式

一、单例模式之饿汉方式

public class ThreadDemo84 {

    //单例类
    static class Singleton{
        //单例模式的3个步骤

        //1.将构造函数设置为私有的，不让外部可见（单例模式是不可以new的）

        /**
         * java 默认的构造函数是public的，所以要显示将构造方法设置为私有的，这样才可以将将public的构造方法覆盖掉
         */
        private Singleton(){
        }

        //2.创建私有的静态的类变量（让底下的第三步方法返回）
        private static Singleton singleton = new Singleton();

        //3.给外部提供的获取单例的方法
        //单例不能new，所以使用static
        public static Singleton getInstance() {
            return singleton;
        }
    }

    static Singleton s1 = null;
    static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                s2 = Singleton.getInstance();
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println(s1 == s2);  //如果得到的是true，说明单例模式的书写是正确的
    }
}

true

饿汉方式：

  • 优点：实现简单，不存在线程安全的问题，因为饿汉的方式是随着程序的启动而初始化的，因为类加载是线程安全的，所以他是线程安全的
  • 缺点：随着程序的启动而启动，有可能整个程序的运行周期里面都没有用到，这样就带来了不必要的开销

二、单例模式之懒汉方式

懒汉方式：不见兔子不撒鹰，他不会随着程序的启动而启动，而是等到有人调用它的时候，它才会初始化

/**
 * 单例模式之懒汉方式1（这里的代码是线程不安全的）
 */
public class ThreadDemo85 {

    static class Singleton{
        //1.设置私有的构造函数，防止其他程序进行创建
        private Singleton(){}

        //2.提供一个私有的静态变量
        //因为时懒汉方式，比较懒，所以先不会进行new对象而是设置为null
        private static Singleton singleton = null;

        //3.提供给外部调用（返回一个单例对象给外部）
        public static Singleton getInstance() {
            if (singleton == null) {
                //第一次访问，进行实例化，并且只实例化一次
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用单例对象
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                s2 = Singleton.getInstance();
            }
        });
        t2.start();

        //等待线程执行结束
        t1.join();
        t2.join();
        System.out.println(s1 == s2);   
    }
}


true

但是！！！上面的代码会存在一定的问题，上面的代码是线程不安全的，做一下修改就可以看出来线程不安全的问题的存在了。修改的代码见下面：

public class ThreadDemo86 {

    static class Singleton{
        //1.设置私有的构造函数，防止其他程序进行创建
        private Singleton(){}

        //2.提供一个私有的静态变量
        //因为时懒汉方式，比较懒，所以先不会进行new对象而是设置为null
        private static Singleton singleton = null;

        //3.提供给外部调用（返回一个单例对象给外部）
        public static Singleton getInstance() throws InterruptedException {
            if (singleton == null) {
                Thread.sleep(1000);
                //第一次访问，进行实例化，并且只实例化一次
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用单例对象
                try {
                    s1 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    s2 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();

        //等待线程执行结束
        t1.join();
        t2.join();
        System.out.println(s1 == s2);
    }
}

false

上面的结果是false，就说明不是线程安全的，线程不安全的原因就是两个线程同时进行操作，都操作到要创建单例模式的那一步的时候进行休眠了，这个时候判断的两个线程都是第一次创建单例模式，就会导致线程不安全的问题。

那么如何将上面的线程不安全的代码修改为线程安全的代码呢？见下面的代码：

/**
 * 单例模式之懒汉方式2
 */
public class ThreadDemo87 {

    static class Singleton{
        //1.设置私有的构造函数，防止其他程序进行创建
        private Singleton(){}

        //2.提供一个私有的静态变量
        //因为是懒汉方式，比较懒，所以先不会进行new对象而是设置为null
        private static Singleton singleton = null;

        //3.提供给外部调用（返回一个单例对象给外部）
        //加锁保证线程安全！！！！！！
        public static synchronized Singleton getInstance() throws InterruptedException {
            if (singleton == null) {
                Thread.sleep(1000);  //可以不加
                //第一次访问，进行实例化，并且只实例化一次
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用单例对象
                try {
                    s1 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    s2 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();

        //等待线程执行结束
        t1.join();
        t2.join();
        System.out.println(s1 == s2);
    }
}

true

说明加上锁以后就变成了线程安全的，但是上面的修改方案粒度太多，性能不高

所以使用 双重校验锁来解决：

public class ThreadDemo88 {

    static class Singleton{
        //1.设置私有的构造函数，防止其他程序进行创建
        private Singleton(){}

        //2.提供一个私有的静态变量
        //因为时懒汉方式，比较懒，所以先不会进行new对象而是设置为null
        private static Singleton singleton = null;

        //3.提供给外部调用（返回一个单例对象给外部）
        //加锁保证线程安全！！！！！！
        public static Singleton getInstance() throws InterruptedException {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    //双重校验锁  上面的一行代码和下面的一行代码
                    if (singleton == null) {
                        //第一次访问，进行实例化，并且只实例化一次
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用单例对象
                try {
                    s1 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    s2 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();

        //等待线程执行结束
        t1.join();
        t2.join();
        System.out.println(s1 == s2);
    }
}

true

但是上面的版本不是最终的版本，因为在jvm（会进行优化，导致指令重排序）里面还是存在一定的问题，但是代码演示不出来：

在JVM里面可能会进行指令重排序或者

要解决上面的指令重排序的问题只需要加上关键字volatile，下面的代码就是懒汉方式的最终版本了。

public class ThreadDemo89 {

    //单例模式的最终版本！！！！！
    static class Singleton{
        //1.设置私有的构造函数，防止其他程序进行创建
        private Singleton(){}

        //2.提供一个私有的静态变量
        //因为时懒汉方式，比较懒，所以先不会进行new对象而是设置为null
        //加上关键字volatile防止发生指令重排序的问题
        private static volatile Singleton singleton = null;

        //3.提供给外部调用（返回一个单例对象给外部）
        public static Singleton getInstance() throws InterruptedException {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    //双重校验锁
                    if (singleton == null) {
                        //第一次访问，进行实例化，并且只实例化一次
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用单例对象
                try {
                    s1 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    s2 = Singleton.getInstance();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();

        //等待线程执行结束
        t1.join();
        t2.join();
        System.out.println(s1 == s2);
    }
}


true

三、自定义阻塞队列

import java.util.Random;

/**
 * 数组的方式实现阻塞式队列
 */
public class ThreadDemo91 {

    //自定义阻塞队列
    static class MyBlockQueue{
        private int[] values;   //存放数据的数组
        private int first;
        private int last;
        private int size;

        public MyBlockQueue(int maxSize) {
            values = new int[maxSize];
            size = 0;
            first = 0;
            last = 0;
        }


        /**
         * 添加元素，将元素添加到队尾
         * @param val
         */
        public void offer (int val) throws InterruptedException {
            synchronized (this) {
                //判断容量是否达到最大值
                if (size == values.length) {
                    //阻塞等待消费者先消费
                    this.wait();
                }
                values[last++] = val;
                size++;

                //判断是否是最后一个元素‘
                if (last == values.length) {
                    //循环队列
                    last = 0;
                }
                //唤醒消费者取队列中的信息
                this.notify();  //唤醒另一个
            }
        }

        /**
         * 取队首元素
         * @return
         */
        public int poll() throws InterruptedException {
            int result = 0;
            synchronized (this) {
                //判断队列里面是否有元素
                if (size == 0) {
                    //阻塞等待
                    this.wait();
                }
                result = values[first++];
                size--;

                //判断队首是不是最后一个元素
                if (first == values.length) {
                    first = 0;
                }
                this.notify();  //唤醒生产者生产数据
            }
            return result;
        }
    }


    public static void main(String[] args) {

        MyBlockQueue myBlockQueue = new MyBlockQueue(100);

        //生产者生产数据
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                //添加数据
                while (true) {
                    int num = new Random().nextInt(10);
                    System.out.println("生产数据："+num);
                    try {
                        myBlockQueue.offer(num);  //存入数据
                        Thread.sleep(500);   //休眠500ms，添加数据的速度远远慢于取数据的速度
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        int result = myBlockQueue.poll();
                        System.out.println("消费数据：" + result);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start();
    }
}

生产数据：6
消费数据：6
生产数据：6
消费数据：6
生产数据：9
消费数据：9
生产数据：9
消费数据：9
生产数据：3
消费数据：3
......
赚钱买phone
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++：单例模式例题解析
linwh8的博客
04-15 1853
C++：单例模式例题解析标签：单例模式 队列by 小威威这篇博文主要是讲解例题，如要深入了解单例模式，可以参考这篇文章：C++设计模式——单例模式，我个人觉得写得不错。单例模式是C++设计模式中的一种，它保证一个类只有一个实例，并提供一个访问它的全局访问点。因为类对象的生成是通过构造函数实现的，为了保证不被随便调用并保存唯一实例，应将构造函数放到private标签内。单例模式还需要提供一个访问它的
Singleton 单例模式（懒汉方式和饿汉方式）
kmoving的专栏
05-13 234
单例模式的概念： 单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 关键点： 1）一个类只有一个实例 这是最基本的 2）它必须自行创建这个实例 3）它必须自行向整个系统提供这个实例 ---------------------------------------------...
第十四节: 介绍四大并发集合类并结合单例模式下的队列来说明线程安全和非安全的场景及补充性能调优问题。
sinolover的专栏
02-06 239
一. 四大并发集合类 背景：我们目前使用的所有集合都是线程不安全的。 　　A. ConcurrentBag：就是利用线程槽来分摊Bag中的所有数据，链表的头插法,0代表移除最后一个插入的值. 　　(等价于同步中的List) 　　B. ConcurrentStack：线程安全的Stack是使用Interlocked来实现线程安全, 而没有使用内核锁. 　　(等价于同步中的数组) 　　C...
单例模式与自定义阻塞队列
ilikeu777的博客
05-28 183
提升程序性能的方法 1、多线程 2、单例模式：整个程序的运行中，只存在一个对象。 饿汉方式：上来不管啥先创建一个对象再说。（不用加锁也是线程安全的） 懒汉方式：当程序启动之后并不会初始化，而是在什么时候调用，什么时候再初始化。 设计模式： 1、单例模式（手写） 2、工厂模式（简单工厂、抽象工厂） 3、模板模式 … 饿汉方式 public class ThreadDemoEH1 { static class Singleton{ //1、创建私有的构造函数(为了防止其他类直接创建)
java线程笔记
05-06
在多线程环境下，实现线程安全的单例有几种方法：饿汉式（静态常量）、懒汉式（静态代码块）、双检锁/双重校验锁（DCL，Double-Check Locking）以及静态内部类。其中，DCL是最为推荐的方式，因为它结合了延迟初始化...
Java多线程设计模式（带源码）
04-04
Java中常见的单例实现有懒汉式（线程不安全）、饿汉式（线程安全）、双重检查锁定（DCL，线程安全）等。DCL模式通过`volatile`关键字和`synchronized`关键字确保了线程安全，是推荐的多线程环境下的单例实现方式。 ...
java多线程设计模式详解
01-05
懒汉式单例在多线程环境下可能会出现多个实例，因此需要使用双重检查锁定（Double-Check Locking）或者静态内部类等线程安全的方式来实现。另外，饿汉式单例在类加载时就完成了初始化，因此天生线程安全。 五、读写...
Java-JUC-多线程 进阶
07-05
饿汉式、懒汉式、静态内部类是 Java 中的三种单例模式实现方式。饿汉式单例模式在类加载时创建实例，懒汉式单例模式在第一次访问时创建实例，静态内部类单例模式使用静态内部类来创建实例。 万恶的反射 反射是 ...
互联网高频Java后端面试题20道（适合1~3年）.docx
最新发布
01-29
答案：Java中实现单例模式常见的方法有懒汉式（线程不安全、线程安全）和饿汉式。线程安全的懒汉式通常采用双重检查锁定（DCL）或静态内部类实现，确保单例的唯一性且延迟初始化。饿汉式则在类加载时就创建单例，...
【多线程案例】单例模式 + 阻塞式队列
xqs196301的博客
04-08 809
【多线程案例】单例模式 + 阻塞式队列
单例模式，阻塞队列，定时器
AIJXB的博客
06-13 326
单例模式 是多线程的一个案例，是一种常见的设计模式。 两种实现单例模式的方法： 1、饿汉模式 2、懒汉模式 阻塞队列 是一个先进先出的队列 入队列的时候如果发现队列满了，就会阻塞，直到有其他线程出队列后，才能继续如对类。 出队列时候如果发现队列空了，也会阻塞，直到有其他线程入队列后，才能继续出队列。 public class ThreadDemo3 { static class BlockingQueue { //基于数组实现 private int[] arra
单例模式实现 线程安全的队列 处理
NuClear的.Net专栏
10-16 2142
public sealed class Queue_Lucene //利用队列 处理Lucene.Net增加索引     {         private static Queue_Lucene instance = null;         private Queue_Lucene()         {         }         public static Queue
【理论知识】单例模式（懒汉式+饿汉式+枚举)
m0_64210833的博客
03-26 6206
软件设计模式（Software Design Pattern） 又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。...
队列_单例模式
zrf的专栏
12-21 1167
数据队列，一端接收数据，一端发送数据。用于不同线程的数据共享
Android之Volley框架使用优化--单例模式实现请求队列
ygd1994的专栏
05-09 2260
1.将Volley框架请求队列的单例模式封装成SingleVolleyRequestQueue.java：public class SingleVolleyRequestQueue { //私有化属性 private static SingleVolleyRequestQueue singleQueue; private RequestQueue requestQueue;
单例模式（懒汉式和饿汉式区别）
热门推荐
qq_37904799的博客
08-18 5万+
单例模式 所谓单例模式，就是保证类在内存中只有一个对象 而如何保证类在内存中只有一个对象？ 思考一下，我们平时在实例化类的对象时，基本都是通过new 的方式来实例化一个对象，其实说白了，就是调用了需要实例化类的默认的构造方法，所以为了保证类只有一个对象，我们需要将类的对象设置为private 1）控制类的创建，不让其他类创建本类的对象，即需要设置private属性 2）在本类中定义一个本...
单例模式（懒汉方式和饿汉方式）+双重检验锁
12-25 1600
单例模式（懒汉方式和饿汉方式）+双重检验锁单例模式的概念：单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 1）一个类只有一个实例 这是最基本的 2）它必须自行创建这个实例 3）它必须自行向整个系统提供这个实例 私有成员变量 private static Singleton singleton ;
学习互联网架构第八课（单例和多线程）
u012453843的专栏
06-26 1365
单例模式，最常见的就是饥饿模式和懒汉模式，一个直接实例化对象，一个在调用方法时进行实例化对象。        大家见的最多的莫过于下面这种单例模式了，这种模式是懒汉模式，就是说只有你调用getInstance方法的时候，它才会创建实例。但是这种方式有个非常致命的问题就是在多线程的情况下不能正常工作。 public class Singleton { private static S
java单例模式饿汉懒汉
08-30
Java单例模式包括饿汉式和懒汉式两种实现方式。饿汉式是在类加载阶段就创建实例并持有，而懒汉式则是在需要时才创建实例。 饿汉模式是指在类加载阶段就创建出实例的，因此它的实例化过程相对于普通情况要早很多。这也是为什么叫“饿汉”的原因，就像一个饥饿的人对食物没有抵抗力，一下子就开始吃了一样。 懒汉模式是指在需要时才创建实例。这种方式的优点是节省了资源，只有在需要时才会进行实例化。但是它的缺点是在多线程环境下可能会导致多个线程同时创建实例的问题，需要进行额外的线程安全措施来解决这个问题。 总结来说，饿汉式适合在应用启动时就需要创建实例的情况，因为它的实例化过程早于普通情况。而懒汉式适合在需要时才创建实例的情况，可以节省资源。 需要注意的是，单例模式的使用要根据具体的适应场景来决定，不同的情况下选择不同的实现方式。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Java设计模式之单例模式——饿汉式、懒汉式（初了解）](https://blog.csdn.net/m0_68062837/article/details/127307310)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Java多线程案例之单例模式（饿汉，懒汉）](https://blog.csdn.net/qq_63218110/article/details/128738155)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值