单例模式

最新推荐文章于 2025-08-06 16:23:50 发布
原创 最新推荐文章于 2025-08-06 16:23:50 发布 · 669 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #设计模式 #实例 #单例模式

单例模式

什么是单例模式

Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

定义中有三个要点：

  1. 我们设定的某个类必须有且有一个实例
  2. 这个类必须自己去实例化自己
  3. 这个类需要向整个系统提供调用它的实例的接口

我们可以结合上面的三个要点来推测该设计模式的实现方式：

它需要自己实例化自己，那么就不允许别的类来实例化，所以它的构造函数必定是private 来声明的私有构造；而且它只允许有一个实例，我们必须使用static来声明该类的私有对象，并控制它不会重复的被new出来；该类不允许在别的地方实例化，并且需要向整个整个系统提供获取该类实例的接口，那么我们只能通过static 方法来提供该接口，这样就可以通过接口向整个系统提供该类的实例了。

在日常生活中使用的打印机就可以类比出一个单例模式，我们的电脑可以连接若干个打印机，但是每个打印机只能同时打印一份文件，而无法同时执行两个打印作业。

在 Java 语言中，这样的行为能带来两大好处：

  1. 对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
  2. 由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。
单例模式分类

单例模式一般分为两类：饿汉式和懒汉式。

饿汉式：不管单例类的实例是否要使用，只要类初始化时，就将静态实例创建出来。

public class HungrySingleton {
    //私有的静态实例
    private final static HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();

    //私有构造，避免其它的类实例化
    private HungrySingleton() {}

    //对外提供的实例接口
    public static final HungrySingleton getInstance(){
        return HUNGRY_SINGLETON;
    }

    //该实例可以向外提供的方法
    public void print(String msg){
        System.out.printf(msg);
    }
}

那么我可以在外部这样调用

public class MainClass {

    public static void main(String[] args){
        //不能声明，因为该类使用了私有的构造
//        HungrySingleton hungrySingleton = new HungrySingleton();

        HungrySingleton.getInstance().print("饿汉模式，外部调用饿汉的打印方法");
    }
}

饿汉模式比较简单，也很好理解，而且它是线程安全的，它基于Classloader机制避免的线程安全问题，但是它在类初始化的时候就实例化了，对于性能有一定的影响。最好的情况是，当我们需要使用它的时候在实例化，而不是在类初始化的时候就实例化。这就需要下面的懒汉式了。

懒汉式：相对上面的饿汉时，懒汉式主要在于类实例化的延迟加载。

public class LazySingleton {
    //私有的静态实例
    private static LazySingleton sLazySingleton = new LazySingleton();

    //私有构造，避免其它的类实例化
    private LazySingleton() {
    }

    //对外提供的实例接口
    public static final LazySingleton getInstance() {
        //如果类没有实例化，才去实例化
        if (sLazySingleton == null) {
            sLazySingleton = new LazySingleton();
        }
        return sLazySingleton;
    }

    //该实例可以向外提供的方法
    public void print(String msg) {
        System.out.printf(msg);
    }
}

上面的代码简单实现了延迟加载的懒汉式单例模式。只有当我们需要实例化的时候才去实例化。上面的单例实现方式很简单，但是它存在多线程问题。存在问题的地方主要在对外提供实例的接口方法中;对于这个地方我们来简单看看。对于下面的方法：

    //对外提供的实例接口
    public static final LazySingleton getInstance() {
        //如果类没有实例化，才去实例化
        if (sLazySingleton == null) {
            sLazySingleton = new LazySingleton();
        }
        return sLazySingleton;
    }

如果现在存在着线程A和B，线程A执行到了 if(sLazySingleton == null)，线程B执行到了 sLazySingleton = new LazySingleton();线程B虽然实例化了一个sLazySingleton，但是对于线程A来说判断sLazySingleton还是木有初始化的，所以线程A还会对sLazySingleton进行初始化。这样就会有两个实例。就违背了单例的原则。那么怎么解决呢？很多人肯定都知道，涉及到多个线程同时访问同一个方法，那么必然涉及到 锁的问题，肯定会用到 synchronized关键字，这样我们就给当前方法加上了锁，两个线程不能同时访问该同步方法。那么就成了下面的这样：

public class LazySingleton {
    //私有的静态实例
    private static LazySingleton sLazySingleton = new LazySingleton();

    //私有构造，避免其它的类实例化
    private LazySingleton() {
    }

    //对外提供的实例接口
    public static final synchronized LazySingleton getInstance() {
        //如果类没有实例化，才去实例化
        if (sLazySingleton == null) {
            sLazySingleton = new LazySingleton();
        }
        return sLazySingleton;
    }

    //该实例可以向外提供的方法
    public void print(String msg) {
        System.out.printf(msg);
    }
}

synchronized修饰静态方法，使用的该类的class文件对象，它的作用范围是整个静态方法。虽然锁住的整个静态并不复杂，但是还有没有更好一些的方式，锁住的内容更少一些呢？答案是肯定synchronized不光可以修饰方法，还可以修饰代码块，通过上面我们知道线程安全问题主要在不同线程实例化的过程中。那么我们就可以在这个地方放做文章了。我们可以将实例化使用代码块包括起来，给它上锁，如下：

public class LazySingleton {
    //私有的静态实例
    private static LazySingleton sLazySingleton = new LazySingleton();

    //私有构造，避免其它的类实例化
    private LazySingleton() {
    }

    //对外提供的实例接口
    public static final LazySingleton getInstance() {
        //如果类没有实例化，才去实例化
        if (sLazySingleton == null) {
            //给实例化过程加锁
            synchronized (LazySingleton.class) {
                sLazySingleton = new LazySingleton();
            }
        }
        return sLazySingleton;
    }

    //该实例可以向外提供的方法
    public void print(String msg) {
        System.out.printf(msg);
    }
}

通过上面我们看到我们在给实例化加了锁，这样就可以避免多线程的问题了吗？是否还有其它问题呢？当两个线程A和B，同时执行到加锁的代码块，A先进去实例化后，A出来，然后B进去，又实例了一次，所有还是问题的，怎么解决呢？解决方案很简单，当实例不为空时就不在去实例化了。我们进行双重校验。如下：

public class LazySingleton {
    //私有的静态实例
    private static LazySingleton sLazySingleton = new LazySingleton();

    //私有构造，避免其它的类实例化
    private LazySingleton() {
    }

    //对外提供的实例接口
    public static final LazySingleton getInstance() {
        //如果类没有实例化，才去实例化
        if (sLazySingleton == null) {
            //给实例化加锁,并添加双重验证
            synchronized (LazySingleton.class) {
                if (sLazySingleton == null) {
                    sLazySingleton = new LazySingleton();
                }
            }
        }
        return sLazySingleton;
    }

    //该实例可以向外提供的方法
    public void print(String msg) {
        System.out.printf(msg);
    }
}

这样就解决了延迟加载而且线程安全的问题。

其实延迟加载在真正的使用过程中是很少的。一般都是类初始化的时候，便需要实例化，如果很明确的知道不需要延迟实例化，那么我们仅仅使用饿汉式单例模式就可以了。

在程序中如果不涉及到多线程操作，但涉及到延迟加载，我们就可以不给实例化加锁。这样也可以节省一部分性能。

懒汉式的单例其它写法：

一般在开发中都会注意延迟加载和线程安全问题，就算再小的几率不去使用，也需要注意，那么懒汉式就成了重重之重了，所以研究的人多了，写法也就多了。下面就一一介绍。

懒汉变种：
public class VariantSingleton {
    private static VariantSingleton sInstance = null;

    static {
        sInstance = new VariantSingleton();
    }

    private VariantSingleton() {
    }

    public static VariantSingleton getInstance() {
        System.out.printf(sInstance.toString());
        return sInstance;
    }

    //该实例可以向外提供的方法
    public void print(String msg) {
        System.out.println(msg);
    }
}
内部类式：

这个是我常用的一种，因为它写法简单，又兼顾延迟加载和多线程问题。下面看代码：

public class InnerClassSingleton {
    //私有构造，避免其它的类实例化
    private InnerClassSingleton() {}

    private static final class InnerSingletonHolder {
        //基于Classloader机制避免的线程安全问题
        private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
    }

    //对外提供的实例接口
    public static InnerClassSingleton getInstance() {
        return InnerSingletonHolder.INNER_CLASS_SINGLETON;
    }

    //该实例可以向外提供的方法
    public void print(String msg){
        System.out.println(msg);
    }
}

我经常使用这种方式的原因是：这种方式能达到双检锁方式一样的功效，但实现更简单。

枚举方式：
public enum EnumSingleton {
    SINGLETON;

    public void print(String msg) {
        System.out.println(msg);
    }
}

如果看过Effective Java 的同学，应该知道这是作者Josh Bloch 比较提倡的方式；它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，使用的时候需要稍微注意。但是 enum 实际上也是一个Java 类，只不过 Java 编译器帮我们做了语法的解析和编译而已。如果我们使用enum,性能上会有影响，如果是做Android开发的同学，需要注意一下。

为什么要使用单例模式？

结合上面我们可以知道，单例在整个系统中只会存留一个实例，在开发当中，我们可以使用单例来保存一些应用配置，也方便资源之间的互相通信；不会频繁的实例化对象，相应的也会节省很多内存。

使用单例模式有时可以避免过多的使用静态方法。那么问题来了，为什么不能使用静态方法来替代单例模式呢？

虽然使用静态方法也能实现相同的目的。但是他们一个是基于对象的，一个是面向对象的；单例是面向对象的，面相对象的代码提供一个更好的编程思想。

如果一个方法和它所在的类的实例无关，那么这个方法就应该是静态的，比如我们的工具类，提供了各种工具方法。反之那这个方法就是非静态的。如果我们确实应该使用非静态方法，但是创建类时只需要维护一个实例，那么这就是单例模式。

比如说我们在系统运行时候，就需要加载一些配置和属性，这些配置和属性是一定存在了，又是公共的，同时需要在整个生命周期中都存在，所以只需要一份就行，这个时候如果需要我再需要的时候new一个，再给他分配值，显然是浪费内存并且再赋值没什么意义，所以这个时候我们就需要单例模式或静态方法去维持一份且仅这一份拷贝，但此时这些配置和属性又是通过面向对象的编码方式得到的，我们就应该使用单例模式，或者不是面向对象的，但他本身的属性应该是面对对象的，我们使用静态方法虽然能同样解决问题，但是最好的解决方案也应该是使用单例模式。(引自为什么要用单例模式？)

扩展，控制多个实例

如果我们想控制多个实例？怎么办呢？我们可以使用Map来控制；我们使用Map来缓存创建过的对象。

public class MultiSingleton {
    //缓存的key的前缀
    private final static String KEY_PRE = "key_pre";
    //使用Map作为容器缓存实例对象
    private static Map<String, MultiSingleton> map = new HashMap<>();
    //初始化时实例的index
    private static int sIndex = 1;
    //允许控制的实例的最大个数
    private final static int NUM_MAX = 3;

    private MultiSingleton() {
    }

    public static synchronized MultiSingleton getInstance() {
        //使用前缀+当前实例的index
        String key = KEY_PRE + sIndex;
        MultiSingleton singleton = map.get(key);
        if (singleton == null) {
            singleton = new MultiSingleton();
            map.put(key, singleton);
        }
        //每调用一次，实例创建一个，实例的index+1
        sIndex++;
        if (sIndex > NUM_MAX) {
            sIndex = 1;
        }
        return singleton;
    }

下面是调用：

public static void main(String args[]) {
    MultiSingleton t1 = MultiSingleton.getInstance();
    MultiSingleton t2 = MultiSingleton.getInstance();
    MultiSingleton t3 = MultiSingleton.getInstance();
    MultiSingleton t4 = MultiSingleton.getInstance();
    MultiSingleton t5 = MultiSingleton.getInstance();
    MultiSingleton t6 = MultiSingleton.getInstance();
    System.out.println(t1.toString());
    System.out.println(t2.toString());
    System.out.println(t3.toString());
    System.out.println(t4.toString());
    System.out.println(t5.toString());
    System.out.println(t6.toString());
}

下面为输出：

me.liteng.example.singleton.MultiSingleton@14ae5a5
me.liteng.example.singleton.MultiSingleton@7f31245a
me.liteng.example.singleton.MultiSingleton@6d6f6e28
me.liteng.example.singleton.MultiSingleton@14ae5a5
me.liteng.example.singleton.MultiSingleton@7f31245a
me.liteng.example.singleton.MultiSingleton@6d6f6e28

我们可以看到只有三个实例，在我们控制的实例范围内。

单例模式详解
yk_dflkg的博客
04-17 1770
单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。简单来说，单例模式就是保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式是一种简单但功能强大的设计模式，它确保一个类只有一个实例，并提供全局访问点。饿汉式（静态常量/静态代码块）懒汉式（普通/同步方法）双重检查锁静态内部类枚举每种实现方式都有其优缺点，应根据具体需求选择合适的实现。在使用单例模式时，需要特别注意线程安全、序列化问题和反射攻击等。
设计模式-单例模式
HL_LOVE_C的博客
01-03 1627
单例模式是一种设计模式，它。就像是在一个软件系统中，某些资源或者对象只需要存在一个就可以满足系统的需求，比如系统的配置管理器、数据库连接池等。通过单例模式，可以避免创建多个实例导致的资源浪费、数据不一致等问题。
单例模式深度剖析：各种实现方式的优缺点对比
热门推荐
张彦峰的博客
04-21 172万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 11万+
C++ 单例模式的几种实现方式。
单例模式的实现
Hardy Army的博客
07-06 1427
当在应用程序中需要控制资源共享、进行配置管理和日志记录等操作时，一种常见的需求是希望通过一个全局访问点，让程序无论在哪个地方，只要能够访问到，就可以通过这个全局访问点，来获取相关实例信息。对于懒汉式单例模式，单例实例在第一次被使用时构建，延迟初始化，相对资源利用率高。如果学过Spring的小伙伴，应该清楚，Spring框架中，默认情况下管理的Bean是单例的，这也意味着Spring容器在创建和管理Bean时，每个Bean只会有一个实例，并且这个实例会被所有需要它的地方共享。：避免重复创建实例，节省资源。
设计模式之单例模式
liang8999的博客
03-17 1415
态域，从而创建SingleStaticClass的实例，由于是静态的域，因此只会在虚拟机装载类的。频繁的创建和销毁时，而且创建或销毁时性能又无法优化，此时单例模式的优。饿汉式在jvm加载类时就会创建全局的实例，实例的引用用final修饰，表示实例创建成功。这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个静态域的访问，在系统中，若要求一个类只有一个对象，如果出现多个对象就会出现异常，则可以采用单例。2.1）由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要。
Java单例模式
weixin_68901096的博客
01-06 1352
5中常见的单例模式，各有优缺点。
C++ 单例模式
u011718663的博客
04-24 4万+
原创文章，转载请注明出处。 本文主要从单例的用处以及问题所做介绍
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 101万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
C++单例模式详解
见牛羊的博客
02-05 2724
起因是在程序中重复声明了一个单例模式的变量，后来程序怎么调都不对，最后发现变量是用单例模式，修改是全局的，所以决定好好梳理一下单例模式。首先，为什么要用单例模式，就是因为我们希望一个类只有唯一一个实例，并且提供一个全局的访问点。从这个描述不难看出，这个实例应该是要static来修饰的。。
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
浅谈Spring单例Bean与单例模式的区别
08-28
"浅谈Spring单例Bean与单例模式的区别" 本文主要介绍了Spring单例Bean与单例模式的区别，通过对比两者的定义、实现机制和应用场景，帮助读者更好地理解这两种概念的异同。 一、单例模式的定义和实现 单例模式是一...
JS 设计模式之：单例模式定义与实现方法浅析
11-21
本文实例讲述了JS 设计模式之：单例模式定义与实现方法。分享给大家供大家参考，具体如下： 良好的设计模式可以显著提高代码的可读性，降低复杂度和维护成本。笔者打算通过几篇文章通俗地讲一讲常见的或者实用的设计...
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
Java单例模式实现静态内部类方法示例
08-29
"Java单例模式实现静态内部类方法示例" Java单例模式是软件设计模式中最基本和最常见的一种设计模式，也是最容易理解的一种设计模式。它的主要思想是确保某个类只有一个实例，并且提供一个全局访问点来访问该实例。...
需求EAV模型的优化与思考
最新发布
HAN_789的博客
08-06 511
针对EAV（Entity-Attribute-Value）存储模型及Elasticsearch集成需求，以下是详细方案设计和实现建议。
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
u010360138的博客
08-05 1198
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
Java中的RabbitMQ完全指南
H1658554092的博客
07-31 1103
Java中的RabbitMQ完全指南
菜鸟集团招Java研发啦
jobleap.cn求职助手首页
08-04 536
菜鸟集团招聘JAVA研发工程师，工作地点杭州。岗位职责包括分布式系统开发、高性能服务端程序设计、搜索引擎模块实现及海量数据处理。要求精通JAVA等编程语言，熟悉网络编程、Linux环境和数据库技术，具备扎实的算法基础。优先考虑有互联网实习经历、ACM竞赛获奖或学术成果的候选人。该职位面向具备良好学习能力和团队协作精神的技术人才。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值