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

谁践踏了优雅 2022-08-28 13:49 119阅读 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 条评论，119人围观）

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

相关阅读

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

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

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

相关 JAVA设计模式（一）单例模式

[format_png][] 1.介绍单例模式是一种对象创建型模式，保证一个类只有一个实例，其私有化构造方法公开一个全局访问的代理方法。 ...

素颜马尾好姑娘i/ 2024年04月17日 06:29/ 0 赞/ 12 阅读

相关 java单例模式理解_JAVA单例模式之我的理解

单例模式是很常见的一种设计模式，一般用在线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象、数据库访问对象等地方。这些应用都或多或少具有资源管理器的功能。每台计算机

浅浅的花香味﹌/ 2022年11月02日 15:23/ 0 赞/ 100 阅读

相关一篇文章带你彻底理解javascript词法作用域

文章目录前言正文词法阶段词法作用域的查找欺骗词法 eval wit

﹏ヽ暗。殇╰゛Y/ 2022年10月08日 11:15/ 0 赞/ 140 阅读

相关一篇让你轻松理解 Git 指令本质的文章

![42b588bc072b780d7cda5eaf0188ba34.png][] 0 前言作为当前世界上最强大的代码管理工具Git相信大家都很熟悉，但据我所知有很大一

不念不忘少年蓝@/ 2022年10月07日 11:49/ 0 赞/ 68 阅读

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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