首页 / 设计模式 / JAVA设计模式之单例模式（超详细）

JAVA设计模式之单例模式（超详细）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JAVA设计模式之单例模式（超详细），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7868字，纯文字阅读大概需要12分钟。

内容图文

单例模式有两种实现方式，一种是饿汉式，一种是懒汉式。

饿汉式：类加载到内存后，就实例化一个单例，JVM保证线程安全，简单实用，推荐使用！唯一缺点，不管用到与否，类装载时就完成实例化，也就是Class.forName("")加载到内存就会实例化。（不过话又说回来，你如果不用它，你要装载它干啥）。

懒汉式：类加载到内容后，不会实例化一个单例，而是在需要时才实例化，但是实现这个方式需要考虑到一些问题，下面我们来分析。

1、饿汉式

一、直接初始化

public class MgrTest01 {
    private static final MgrTest01 INSTANCE = new MgrTest01();

    private MgrTest01() {};

    public static MgrTest01 getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        MgrTest01 mgrTest011 = MgrTest01.getInstance();
        MgrTest01 mgrTest012 = MgrTest01.getInstance();

        System.out.println(mgrTest011 == mgrTest012);
    }
}

执行结果：true

二、使用静态语句初始化（本质上和直接初始化没有什么区别）

public class MgrTest02 {
    private static final MgrTest02 INSTANCE;

    static {
        INSTANCE = new MgrTest02();
    }

    private MgrTest02() {};

    public static MgrTest02 getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        MgrTest02 mgrTest011 = MgrTest02.getInstance();
        MgrTest02 mgrTest012 = MgrTest02.getInstance();

        System.out.println(mgrTest011 == mgrTest012);
    }
}

结果：true

2、懒汉式

一、按需初始化

public class MgrTest03 {
    private static MgrTest03 INSTANCE;

    private MgrTest03() {};

    public static MgrTest03 getInstance()  {
        if(null == INSTANCE){
            try {
                Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new MgrTest03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest03.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest03.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象可能会不同（虽然达到了按需初始化的目的，但是却带来了线程不安全的问题）

JAVA设计模式之单例模式（超详细） - 文章图片

问题原因：因为在对象还没有创建之前。多个线程同时调用getInstance方法获取实例的时候，可能存在第一个线程进入了if语句，但是还没有来的及执行实例化对象，后面线程也进入了if语句。等到第一个线程实例化之后，虽然这个时候再有线程调用getInstance，不会再进入if语句直接拿对象，但是已经进入if语句的线程又创建了新的对象。（注意：我们可以看到前五次的对象可能不是同一个，但是后五次肯定是同一个了(中间加入延迟是模拟在对象创建之后再调用getInstance的场景)，所以这个问题是在对象还没有创建之前，然后有多个线程同时调用getInstance方法可能出现的问题）

二、可以通过synchronized来解决上个问题

public class MgrTest04 {
    private static MgrTest04 INSTANCE;

    private MgrTest04() {};

    public static synchronized MgrTest04 getInstance()  {
        if(null == INSTANCE){
            try {
                Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new MgrTest04();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest04.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest04.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象都是同一个（可以实现懒加载，并且不会有线程安全的问题，但是效率下降）

JAVA设计模式之单例模式（超详细） - 文章图片

但是又引发了另一个问题，每次调用getInstance方法的时候都要加锁，因为调用加了synchronized的方法每次都要去判断有没有申请到这把锁，执行效率就降低了。本来我们只是解决在INSTANCE还没有实例化的时候线程安全问题，而INSTANCE初始化之后调用getInstance方法是不会有线程安全问题的，所以我们只需要在INSTANCE为空的时候才需要加锁获取，已经不为空了就没有必要还加锁获取。

三、通过减小同步代码快的方式提高效率，但是不可行（需要注意）

public class MgrTest05 {
    private static MgrTest05 INSTANCE;

    private MgrTest05() {};

    public static MgrTest05 getInstance()  {
        if(null == INSTANCE){
            synchronized (MgrTest05.class){
                try {
                    Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new MgrTest05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest05.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest05.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象可能会不同（虽然减少了同步代码块，但是出现了线程安全问题）

JAVA设计模式之单例模式（超详细） - 文章图片

问题原因：和上面讲的懒加载第一种方式问题类似，虽然把实例化INSTANCE对象的代码同步了，但是还是有可能存在第一个线程进入了if语句，然后进入了同步代码块上锁了，但是还没有来的及执行实例化对象，后面线程也进入了if语句，只是被锁在实例化对象语句外面，等到第一个进入同步代码的线程出来后，被锁在外面的线程还是可以进入，然后实例化了新的对象，就出现了上面类似的线程安全问题。

四、通过双重检查来解决上一个问题

public class MgrTest06 {
    //做JIT优化的时候会指令重排 加上volatile关键之阻止编译时和运行时的指令重排
    private static volatile MgrTest06 INSTANCE;

    private MgrTest06() {};

    public static MgrTest06 getInstance()  {
        if(null == INSTANCE){
            synchronized (MgrTest06.class){
                //双重检查
                if(null == INSTANCE){
                    try {
                        Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new MgrTest06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest06.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest06.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象都是同一个（可以实现懒加载，并且不会有线程安全的问题，同时也解决了效率问题）

JAVA设计模式之单例模式（超详细） - 文章图片

这样实现了只在INSTANCE为空的时候才需要加锁获取实例，已经不为空了再调用getInstance方法就判断不为空，然后直接获取。

五、静态内部类单例

public class MgrTest07 {
    private MgrTest07() {};

    private static class MgrTest07Holder{
        private static final MgrTest07 INSTANCE = new MgrTest07();
    }

    public static MgrTest07 getInstance(){
        return MgrTest07Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest07.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest07.getInstance())).start();
        }
    }
}

执行结果：（JVM保证单例，虚拟机加载类的时候只加载一次，所以INSTANCE也只会加载一次，同时实现了懒加载，因为加载外部类时不会加载内部类）

JAVA设计模式之单例模式（超详细） - 文章图片

六、枚举单例（不仅可以解决线程同步，还可以防止反序列化）

public enum MgrTest08 {

    INSTANCE;

    public static void main(String[] args){
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest08.INSTANCE.hashCode())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest08.INSTANCE.hashCode())).start();
        }
    }
}

执行结果：

JAVA设计模式之单例模式（超详细） - 文章图片

总结：一般使用直接初始化单例的和静态内部类单例的方式就可以了，不过使用枚举单例的方式更好，因为只有枚举单例，不仅可以解决线程安全问题，还可以防止反序列化，主要看实际开发中需不需要考虑到这些问题，来选择哪种方式实现单例就可以了。

序列化的问题：

为什么在做单例的时候要防止这一点？

因为java的反射是通过一个class文件，然后把整个class加载到内存，再把它创建一个实例出来，而除了枚举方式，其它的都可以找到class文件通过反序列化的方式（反射）再创建一个实例出来，如果想让它不能被反序列化需要设置一些变量，过程比较复杂。

枚举单例为什么可以防止反序列化？

因为枚举类没有构造方法（java规定没有构造方法），就算拿到class文件也没有办法实例化一个对象出来，它反序列化只是一个INSTANCE值（当前案例），然后根据这个值来找对象的话，找到的是和单例创建的同一个对象。

内容总结

以上是互联网集市为您收集整理的JAVA设计模式之单例模式（超详细）全部内容，希望文章能够帮你解决JAVA设计模式之单例模式（超详细）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/634293.html

来源：【匿名】

【上一篇】5分钟学会java设计模式及设计原则【下一篇】介绍php设计模式中的工厂模式

更多 ►

【JAVA设计模式之单例模式（超详细）】教程文章相关的互联网学习教程文章

基于JAVA的设计模式之单例模式【代码】

概念　　　　于大二上学期面向对象C++期中考试中有这么道题：一个Computer有多个USB插口，那么意味着这台电脑可以插多个鼠标，但是无论你如何拔插多少个鼠标，桌面上的鼠标一直只显示一个，且多个硬件鼠标都可以操控这个桌面上的鼠标，就这个场景进行程序设计。当时由于没有接触过设计模式当场就蒙蔽了，现在想起来较为简单。　　　　单利模式保证内存中有且仅有一个对象，对内私有化构造函数，对外提供静态的获取对象引用的方法。...

Java中的GOF23（23中设计模式）--------- 单例模式（Singleton）【代码】

Java中的GOF23（23中设计模式）--------- 单例模式（Singleton）　　在Java这这门语言里面，它的优点在于它本身的可移植性上面，而要做到可移植的话，本身就需要一个中介作为翻译工作，以达到本地和Java的统一，但是就这点而言就相当的消耗资源，所以就Java程序员需要不断的去优化自己的代码。今天所研究的单例模式就是在这样的条件下产生的，　　　　所谓单例模式，就是只有一个实例，在堆里面只有一个。假如我们的实例，就需要一...

java设计模式--单例模式【代码】【图】

1，定义：一个类只有一个实例，且该类能自行创建这个实例的模式，2，特点：只有一个实例对象，单例对象有单例类自行创建、对外提供一个访问该单例的全局访问点3，结构　　单例类的主要角色　　　　单例类：包含一个实例且能自行创建这个实例的类　　　　访问类：使用单例的类 4，懒汉单例　　类加载的时候没有单例，只有当第一次调用getInstance的时候才会创建这个实例publicclass LazySingleton{//保证线程同步privatestaticvolat...

23中设计模式之单例模式

java单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。特点：1，一个类只能有一个实例；2，自己创建这个实例；3，整个系统都要使用这个实例。--------------------------------Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。外部资源：譬如每台计算机可以有若干个打印...

设计模式之- 单例模式（Singleton Pattern）【代码】【图】

单例模式单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。C++实现：#include<iostream>usingnamespace std;class Singleton{ private:Si...

设计模式之单例模式【代码】【图】

Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？客户程序在调用某一个类时，它是不会考虑这个类是否只能有一个实例等问题的，所以，这应该是类设计者的责任，而不是类使用者的责任。从另一个角度来说，Singleton模式其实也是一种职责型模式。因为我们创建了一个对象，这个对象扮演了独一无二的角色，在这个单独的对象实...

C#设计模式(1)——单例模式【代码】【图】

原文地址：http://www.cnblogs.com/zhili/p/SingletonPatterm.html一、引言最近在设计模式的一些内容，主要的参考书籍是《Head First 设计模式》，同时在学习过程中也查看了很多博客园中关于设计模式的一些文章的，在这里记录下我的一些学习笔记，一是为了帮助我更深入地理解设计模式，二同时可以给一些初学设计模式的朋友一些参考。首先我介绍的是设计模式中比较简单的一个模式——单例模式（因为这里只牵涉到一个类）二、单例模式...

入门设计模式——单例模式【代码】

参考文章：http://www.cnblogs.com/TomXu/archive/2012/02/20/2352817.html单例模式：保证一个类只有一个实例，实现方法是先判断实例存在与否，如果存在直接返回，如果不存在就创建了再返回，确保一个类只有一个实例对象。在javascript里，单例作为一个命名空间提供者，从全局命名空间里提供了一个唯一的访问点来访问该对象。自我感受：单例模式是在内部实例化了一次对象A，然后返回这个实例instance,所以在外部再new一个对象A的时...

Delphi 设计模式：《HeadFirst设计模式》Delphi2007代码---单例模式之ChocolateBoiler[转]【图】

1 2{《HeadFirst设计模式》之单例模式 } 3{ 编译工具: Delphi2007 for win32 } 4{ E-Mail : guzh-0417@163.com } 5 6unit uChocolateBoiler; 7 8interface 910type11 TChocolateBoiler = class(TObject)12 strict private13 class var14 FUniqueInstance: TChocolateBoiler;15 strict private16 FEmpty : Boolean;17 FBoiled: Boolean;18 constructor Create;19 public20 class function GetInstance: TC...

【JS 设计模式】用单例模式（Singleton）来封装对数据的增删除改查

单例模式单例模式的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”var Singleton = (function(){SingletonClass() {}var singleton = null;return {getInstance: function() {if (sin...

[设计模式] 单例模式【代码】

目录概述原理Show Code概述设计模式---- 单例模式这是一个创建型的设计模式它保证某一个类只会有一个实例，实际用途就是比如说我要写一个全局的配置类，或者数据库操作类，全局可能都会访问到，但是需要保证信息同步。而在使用这种设计模式之前，我的解决方案就是通过继承的方式解决，或者大量的全局静态变量，尤其是后者，实际上并不太好用。原理通过将构造函数设置为private的方式，使得不能通过new创建实例创建实例则是通过创建...

设计模式——创建型模式之单例模式【代码】【图】

单例模式　　单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。　　　　　　注意：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他...

应用最广的设计模式——单例模式【代码】

介绍单例模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需拥有一个全局对象，这样有利于我们协调系统整体的行为。定义确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例使用场景确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个...

设计模式之单例模式【代码】

privatestatic Singleton instance;public Singleton(){ //private 不让客户端 new }publicstatic Singleton GetInstance(){if (instance == null){instance = new Singleton();}return instance;}客户端protectedvoid Page_Load(object sender, EventArgs e){Singleton s1 = Singleton.GetInstance();Singleton s2 = Singleton.GetInstance();if (s1 == s2){Response.Write("我们是同一个<br>"); }Singleton s3 = new Sing...

设计模式之单例模式三（更好的实现方式）【图】

? ? ? ? ??大学之道，在明明德，在亲民，在止于至善。?《礼记 ?大学》? ? ? ??今天考完了安卓这门课，100分钟的考试50分钟就交卷离开考场了，回想一下大学生活就这么没了，虽然小菜现在还是大三但是大四学校安排是实习到下年四月份，学校里面已经没有了课程。想想自己的青春就这么没了，也是有点伤感呢。。最近在看《研读设计模式》这本书感觉写的很不错，通俗易懂哈。? ? ? ? ?之前写过懒汉式单例模式在多线程环境下，会造成不只创...

设计模式 - 相关标签

设计模式六大原则

设计模式 - 最热教程

Java的设计模式（7）— 生产者-消费者模...PHP设计模式——策略模式_PHP教程 JavaScript设计模式经典之简单工厂模式...Java设计模式：代理模式 Java设计模式的常见应用场景 php – Laravel – 在视图中处理if / e...CoreJava学习第十五课-反射，枚举，标注...java – 当if-else增长时,应该使用什么...C#设计模式(6)——原型模式（Prototype...Python 中最简最好的设计模式

首页 / 设计模式 / JAVA设计模式之单例模式（超详细）

JAVA设计模式之单例模式（超详细）

内容导读

内容图文

1、饿汉式

2、懒汉式

内容总结

内容备注

内容手机端

【JAVA设计模式之单例模式（超详细）】教程文章相关的互联网学习教程文章

基于JAVA的设计模式之单例模式【代码】

Java中的GOF23（23中设计模式）--------- 单例模式（Singleton）【代码】

java设计模式--单例模式【代码】【图】

23中设计模式之单例模式

设计模式之- 单例模式（Singleton Pattern）【代码】【图】

设计模式之单例模式【代码】【图】

C#设计模式(1)——单例模式【代码】【图】

入门设计模式——单例模式【代码】

Delphi 设计模式：《HeadFirst设计模式》Delphi2007代码---单例模式之ChocolateBoiler[转]【图】

【JS 设计模式】用单例模式（Singleton）来封装对数据的增删除改查

[设计模式] 单例模式【代码】

设计模式——创建型模式之单例模式【代码】【图】

应用最广的设计模式——单例模式【代码】

设计模式之单例模式【代码】

设计模式之单例模式三（更好的实现方式）【图】

JAVA - 相关标签

设计模式 - 相关标签

设计模式 - 最新教程

设计模式 - 最热教程