深入理解Java单例模式-优快云博客

本文链接：https://blog.youkuaiyun.com/huangchangjunsatr/article/details/88886350

本文详细介绍了单例模式的概念、特点、优缺点以及常见的五种实现方式，包括饿汉式、懒汉式、双重校验锁、静态内部类和枚举。总结了在不同场景下选择合适单例模式的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、什么是单例模式？

单例模式是很常见的一种设计模式，确保某个类只有一个实例，而且它能够自行实例化并且向整个系统提供这个实例。它的作用是在一个jvm中只能存在一个实例，保证对象的唯一性。它的应用场景有很多，像servlet、spring、struts2、springMVC、连接池、线程池、枚举、常量等都是使用的单例模式。

二、单例模式的特点？

1、单例类只能实例化一次；

2、单例类必须自己创建自己的唯一实例；

3、单例类必须能够给其他对象提供这一实例。

三、单例模式的优缺点？

优点：

1.内存里只有一个实例，减少了内存的开支，尤其是频繁的创建和销毁实例。

2.避免对资源的多重占用。

缺点：

1.没有接口，不能继承，与单一职责原则冲突。

2.线程安全问题。

四、单例模式的创建方式？

1、饿汉式(立即加载)

public class SingleObject {
    //创建SingleObject的一个对象，类初始化时，会立即加载该对象，线程天生安全，调用效率高
    private static SingleObject instance=new SingleObject();

    //让构造函数为private，这样该类就不会被实例化
    private SingleObject(){
        System.out.println("SingleObject被初始化");
    }

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }

    //测试
    public static void main(String [] args){
        SingleObject singleObject1 =SingleObject.getInstance();
        SingleObject singleObject2=SingleObject.getInstance();
        //就该结果的论述：如果为true，说明这两个对象的引用地址一致，也就是说这两个对象是一致的。
        System.out.println(singleObject1 == singleObject2);
    }
}

这种方式比较常用，但容易产生垃圾对象。由于没有加锁，执行效率会提高；因为类加载时就初始化，浪费内存。

2、懒汉式(延迟加载)

public class Singleton {
    //定义未赋值的对象变量
    private static Singleton instance;
    //私有构造
    private Singleton(){
        System.out.println("初始化构造函数。。。");
    }
    //将对象类实例化
    public static Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
    public static void main(String [] args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

这是一种最基本的实现，但是最大的问题就是不支持多线程，因为没有加锁synchronized关键字，所以严格意义上它并不算单例模式，以下是更改形式，能够多线程，但是在性能上会降低一些。

public class Singleton {
    //定义未赋值的对象变量
    private static Singleton instance;
    //私有构造
    private Singleton(){
        System.out.println("初始化构造函数。。。");
    }
    //将对象类实例化
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
    public static void main(String [] args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

这种方式具备很好的lazy loading，能够在多线程中很好的工作，但是，效率会很低，99%情况下不需要同步。

优点：当第一次调用才初始化，避免内存的浪费。

缺点：必须加锁synchronized才能保证单例，但加锁会影响效率。

public class Singleton {
    //定义未赋值的对象变量
    private static Singleton instance;
    //私有构造
    private Singleton(){
        System.out.println("初始化构造函数。。。");
    }
    //将对象类实例化
    public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                instance=new Singleton();
            }
        }
        return instance;
    }
    public static void main(String [] args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }

由于加上synchronized关键字之后的懒汉式执行的效率非常低，所以放弃同步方法，改为同步产生实例化的代码块。但不能起到线程同步的作用，假如一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

3.双重校验锁/双检锁(double-checked locking)

public class Singleton {
    //定义未赋值的对象变量
    private static volatile Singleton instance;
    //私有构造
    private Singleton(){
        System.out.println("初始化构造函数。。。");
    }
    //将对象类实例化
    public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
    public static void main(String [] args){
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。这样，实例化代码只用执行一次，后面再次访问时，判断if(singleton==null)，直接return实例化对象。线程安全，延迟加载，效率高。

4.静态内部类

public class SingleStatic {
    private SingleStatic(){
        System.out.println("初始化构造函数。。。");
    }

    private static class SingleHolder{
        private static final SingleStatic INSTANCE=new SingleStatic();
    }

    public static final SingleStatic getInstance(){
        return SingleHolder.INSTANCE;
    }
}

这种方式使用的是静态内部类，这种方式与饿汉式差不多，但又不尽相同，饿汉式是当类被装载就会实例化，没有lazy-loading的作用，而静态内部类方式在SingleStatic类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonStatic类，从而完成Singleton的实例化。类的静态属性只会在第一次加载类的时候初始化，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。避免了线程不安全，延迟加载，效率高。

5.枚举

public enum  SexEnum {
    student('男');
    private char sex;
    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    SexEnum(char sex){
        this.sex=sex;
    }
    public static void main(String [] args){
        System.out.println(SexEnum.student.getSex());
    }
}

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。