一篇文章让你彻底理解Java的单例设计模式

谁践踏了优雅 2022-08-28 13:49 183阅读 0赞

下文是笔者编写的单例模式实现的八种方式，如下所示:

单例模式的简介

我们将一个类在当前进程中只有一个实例的这种模式，称之为“单例模式”  
那么Java代码如何实现一个单例模式呢？下文将一一到来，如下所示:

单例模式的注意事项:
       1.单例模式在一个进程中只有一个实例
       2.单例类通常由自己创建自身的实例
       3.单例类给其他对象提供的都是同一个实例

测试代码

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    public class Test {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            System.out.println("------单例模式-----");
    
            //创建100个线程进行测试
            
            for(int i=0;i<100;i++) {
                new Thread(()->{
                    System.out.println(Single01.getInstance());
                 }).start();
            }
        }
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

单例实现模式1

饿汉式单例模式：  
直接使用一个静态变量，在JVM加载类时，生成一个单例实例 如下

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    
    public class Single01 {    
        private static final Single01 INSTANCE = new Single01();
    
        private Single01() {}
        
        public static  Single01 getInstance () {
            return INSTANCE;
        }
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

使用static静态代码块生成一个单例类

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    public class Single02 {
        private static final Single02  INSTANCE;
        
        static {
             INSTANCE = new Single02();
        }
           
        private Single02() {}
    
        public static Single02 getInstance() {
            return INSTANCE;    
        }
        public void t() {
             System.out.println("Single02 t方法"
                     + "");
        }
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

使用判断的方式，创建单例模式，  
但是此处不是一个线程安全的创建方式

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    
    /*
     * 这是一个线程不安全的创建单例模式的方式
     * 这是一个懒汉式的创建单例模式的方式
     * */
    public class Single03 {
        private static Single03 INSTANCE;
        private Single03() {    
        }
    
        public  static Single03 getInstance() {
             if(INSTANCE ==null)
             {
                    // 多个线程都会被卡在此处，
                    // 当sleep运行完毕后，多个线程会同时创建实例，此处的代码是产生线程不安全的根源
                 try
                 {
                  Thread.sleep(100);
                 }catch(InterruptedException e)
                 {
                     
                 }
                 INSTANCE = new Single03();
             }
             
             return INSTANCE;
        }    
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

使用 synchronized为方法加上锁,使其线程安全

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    public class Single04 {
        private static volatile Single04 INSTANCE;
        private Single04() {    
        }
    
        /*
         * 懒汉式生成单例实例 此处使用 synchronized 安全锁
         */
        public  static  synchronized Single04 getInstance() {
             if(INSTANCE ==null)
             {
                 try
                 {
                  Thread.sleep(100);
                 }catch(InterruptedException e)
                 {
                     
                 }
                 INSTANCE = new Single04();
             }
             
             return INSTANCE;
        }    
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

减少锁粒度，将synchronized关键字直接加在方法内部具体的位置上

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    public class Single05 {
    
        private static Single05 INSTANCE;
        private Single05() {
            
        }
        public  static   Single05 getInstance() {
             if(INSTANCE ==null)
             {
                    /*
                     * 将锁直接加到方法体里面 此时出现了一个新的问题 当所有的线程都堵塞在此处，也会创建多个实例
                     */
                 synchronized(Single05.class) {
                 try
                 {
                  Thread.sleep(100);
                 }catch(InterruptedException e)
                 {
                     
                 }
                 INSTANCE = new Single05();
                 }
             }     
             return INSTANCE;
        }    
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

将synchronized锁放入在方法体中，同时使用双重检查，避免创建多个实例

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    
    public class Single06 {
        private static Single06 INSTANCE;
        private Single06() {
        }
        public  static   Single06 getInstance() {
             if(INSTANCE ==null)
             {
                 synchronized(Single06.class) {
                 try
                 {
                  Thread.sleep(100);
                 }catch(InterruptedException e)
                 {
                     
                 }
                 if(INSTANCE == null)
                 {
                 INSTANCE = new Single06();
                 }
                 }
             }
             
             return INSTANCE;
        }    
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

使用静态内部类的方式创建一个单例对象  
此方式主要借助JVM加载类时，内部类不会被加载  
当我们使用内部类的时，才会被加载，此时由JVM保证静态内部类的唯一性

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    
    /*
     * 采用内部类的方式实现一个单例模式
     * */
    public class Single07 {
    
        private Single07() {
            
        }
    
        private static class Single07Holder {
            private final static Single07 INSTANCE = new Single07();
        }
    
        public  static   Single07 getInstance() {
            return Single07Holder.INSTANCE;
        }    
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

使用枚举创建一个静态[java教程][java]内部类

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

package com.java265.Singleton;
    
    /*
     * 采用枚举实现一个单例模式
     * */
    public enum Single08 {
    
        INSTANCE;
    
        public static Single08 getInstance() {
            return INSTANCE;
        }     
    }

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

[48304ba5e6f9fe08f3fa1abda7d326ab.png]: /images/20220828/66ec45e8abf04cf58a83bf7938180767.png
[java]: https://www.xin3721.com/eschool/Javaxin3721/

发表评论取消回复

表情：

评论列表（有 0 条评论，183人围观）

还没有评论，来说两句吧...

相关阅读

相关一篇文章带你彻底了解Java常用的设计模式

说到Java开发，设计模式肯定是绕不开的，Java常用的设计模式主要包括很多，一种说是有10种设计模式，还有一种说是23种设计模式。我这边重点解释了开发中常用到的8种设计...

不念不忘少年蓝@/ 2024年05月03日 15:05/ 0 赞/ 70 阅读

相关设计模式篇(Java)：单例模式

> [上一篇：设计模式篇(Java)：前言(UML类图、七大原则)][Java_UML] 四、单例模式所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，

清疚/ 2023年10月12日 21:07/ 0 赞/ 8 阅读

相关深入理解Java设计模式-单例模式

单例模式 1.什么是单例 2.那些地方用到了单例模式 3.单例优缺点 4.单例模式使用

╰半夏微凉°/ 2023年07月14日 08:26/ 0 赞/ 1 阅读

相关一篇文章让你彻底搞清楚Python中self的含义

> 刚开始学习Python的类写法的时候觉得很是麻烦，为什么定义时需要而调用时又不需要，为什么不能内部简化从而减少我们敲击键盘的次数？ > 你看完这篇文章后就会明白所有的疑

超、凢脫俗/ 2022年10月17日 14:59/ 0 赞/ 162 阅读

相关一篇文章让你彻底掌握 shell 语言

> 由于 bash 是 Linux 标准默认的 shell 解释器，可以说 bash 是 shell 编程的基础。 > > 本文主要介绍 bash 的语法，对于 linux

桃扇骨/ 2022年10月01日 07:49/ 0 赞/ 246 阅读

相关一篇文章让你彻底理解Java的单例设计模式

下文是笔者编写的单例模式实现的八种方式，如下所示: 单例模式的简介我们将一个类在当前进程中只有一个实例的这种模式，称之为“单例模式” 那么Java代码如何实现一个单例

谁践踏了优雅/ 2022年08月28日 13:49/ 0 赞/ 184 阅读

相关一篇文章让你彻底搞清楚Python中self的含义

转载地址：http://python.jobbole.com/81921/ 刚开始学习Python的类写法的时候觉得很是麻烦，为什么定义时需要而调用时又不需要

骑猪看日落/ 2022年08月21日 01:12/ 0 赞/ 222 阅读

相关【Java】设计模式：深入理解单例模式

> 什么是设计模式？简单的理解就是前人留下来的一些经验总结而已，然后把这些经验起了个名字叫Design Pattern，翻译过来就是设计模式，通过使用设计模式可以让我们的代码复

雨点打透心脏的1/2处/ 2022年07月18日 11:52/ 0 赞/ 228 阅读

相关一篇文章，让你彻底弄懂生产者–消费者问题

生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生

短命女/ 2022年04月18日 01:25/ 0 赞/ 273 阅读

相关 java 设计模式(一)：单例模式

大白话：在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 > 单例模式的定义与特点单例模式（Singleto

缺乏、安全感/ 2021年10月13日 03:25/ 0 赞/ 248 阅读