【Java进阶营】Java设计模式－单例模式：单例的六种实现

关注

原创最新推荐文章于 2026-06-21 08:02:00 发布 160 阅读 AI 写同款· GEO 优化 ›

详解设计模式:单例的进化之路尽管实现单例模式的具体思想和方法多种多样，也各有千秋和不足，但在实际的使用中，并不是最优的就是最合适的，在使用单例模式时，应该结合具体的项目需求以及场景来选择合适的实现方式。当然，除了上面的两个分类之外，处于对性能、安全等方面的考量，单例模式还演化出了各种实现版本，每一种版本的演进，都是单例的一次**进化与升级，**下面就来看看单例模式的进化之路上都经历了哪些挑战与对抗。实现，该单例不能保证其创建的对象是全局唯一，但是能保证在单个线程中是唯一的，在单线程环境下线程天生安全。测试结果:true。阅读详情

单例模式的定义

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

UML类图

单例类的构造函数是 private 内部私有的，确保外部不能通过 new 的方式创建新对象，内部自行实例化，并对外提供一个访问该单一实例的静态的方法 Instance() 。

单例模式的实现

普通饿汉式

/**
 * 普通饿汉式
 *
 * @author anlingyi
 */
public class Singleton {
    /**
     * 类加载时进行实例化对象
     */
    private static final Singleton SINGLETON = new Singleton();

    /**
     * 私有构造，防止外部new对象
     */
    private Singleton() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static Singleton getInstance() {
        return SINGLETON;
    }

    public void say() {
        System.out.println("普通饿汉式：Hello World!");
    }
}

调用方式：

Singleton singleton = Singleton.getInstance();
singleton.say();

优缺点
优点：类加载时就进行实例化，之后的操作效率会很高。
缺点：由于类加载时就进行实例化，如果后续不对此类进行任何操作，就会导致内存的浪费。

线程不安全的懒汉式

/**
 * 懒汉式（线程不安全）
 *
 * @author anlingyi
 */
public class SingletonTwo {

    private static SingletonTwo instance;

    /**
     * 私有构造，防止外部new对象
     */
    private SingletonTwo() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonTwo getInstance() {
        if(instance == null) {
            instance = new SingletonTwo();
        }

        return instance;
    }

    public void say() {
        System.out.println("懒汉式（线程不安全）：Hello World!");
    }
}

调用方式：

SingletonTwo singleton = SingletonTwo.getInstance();
singleton.say();

优缺点
优点：在第一次调用的时候才进行实例化。
缺点：当多个线程同时进入到 if(instance == null) {…} 时，会创建多个对象。在此我向大家推荐一个架构学习交流圈。交流学习指导伪鑫：1253431195（里面有大量的面试题及答案）里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多

同步锁懒汉式

/**
 * 同步锁懒汉式（线程安全，效率低）
 *
 * @author anlingyi
 */
public class SingletonThree {

    private static SingletonThree instance;

    /**
     * 私有构造，防止外部new对象
     */
    private SingletonThree() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static synchronized SingletonThree getInstance() {
        if(instance == null) {
            instance = new SingletonThree();
        }

        return instance;
    }

    public void say() {
        System.out.println("同步锁懒汉式（线程安全，效率低）：Hello World!");
    }
}

调用方式：

SingletonThree singleton = SingletonThree.getInstance();
singleton.say();

优缺点
优点：在第一次调用的时候才进行实例化，且线程安全。
缺点：使用 synchronized 的方式对方法加锁，会影响效率。

双重校验锁懒汉式

/**
 * 双重校验锁懒汉式（线程安全，且多线程环境下可以保持高性能）
 *
 * @author anlingyi
 */
public class SingletonFour {

    /**
     * volatile是为了防止指令重排序
     */
    private static volatile SingletonFour instance;

    /**
     * 私有构造，防止外部new对象
     */
    private SingletonFour() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonFour getInstance() {
        if(instance == null) {
            synchronized (SingletonFour.class) {
                if(instance == null) {
                    instance = new SingletonFour();
                }
            }
        }

        return instance;
    }

    public void say() {
        System.out.println("双重校验锁懒汉式（线程安全，且多线程环境下可以保持高性能）：Hello World!");
    }
}

调用方式：

SingletonFour singleton = SingletonFour.getInstance();
singleton.say();

优缺点
优点：在第一次调用的时候才进行实例化，且线程安全，效率较高。
缺点：实现复杂，且 volatile 需要在JDK1.5之后的版本才能确保安全。

静态内部类懒汉式

/**
 * 静态内部类懒汉式
 *
 * @author anlingyi
 */
public class SingletonFive {

    /**
     * 私有构造，防止外部new对象
     */
    private SingletonFive() {

    }

    /**
     * 通过静态方法获取对象实例
     *
     * @return
     */
    public static SingletonFive getInstance() {
        return Singleton.SINGLETON;
    }

    public void say() {
        System.out.println("静态内部类懒汉式：Hello World!");
    }

    /**
     * 静态内部类实例化对象
     */
    private static class Singleton {
        /**
         * 类加载时进行实例化对象
         */
        private static final SingletonFive SINGLETON = new SingletonFive();
    }
}

调用方式：

SingletonFive singleton = SingletonFive.getInstance();
singleton.say();

优缺点
优点：只有在调用 getInstance() 方法的时候，静态内部类才会被加载，从而对主类（我们需要的类）进行实例化，即线程安全，又效率高。
缺点：多创建一个类。

枚举类饿汉式（防止反序列化）

/**
 * 枚举类饿汉式（防止反序列化）
 *
 * @author anlingyi
 */
public enum  SingletonSix {
    INSTANCE;

    public void say() {
        System.out.println("枚举类饿汉式（防止反序列化）：Hello World!");
    }
}

调用方式：

SingletonSix singleton = SingletonSix.INSTANCE;
singleton.say();

优缺点
优点：实现简单，防止反序列化生成多个实例，且线程安全。
缺点： Enum 需在JDK1.5之后版本使用。

单例模式的优缺点

优点

单例模式在内存中只有一个实例，减少了内存开支，尤其是频繁的创建和销毁实例。
由于只生成一个实例，所以减少了系统的性能开销。
避免对资源的多重占用，例如写文件操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问。

缺点

单例模式不易扩展，若要扩展，除了修改代码外别无他法。
单例模式对测试不利。
单例模式与单一职责原则有冲突，一个类应该只实现一个逻辑，而不用关心它是否是单例的。

标签

#java #单例模式 #设计模式 #spring #架构

java单例模式实例一个简单的java工程，包含注释，一目了然，其中包含了单例模式的所有实现方式，懒汉式，饿汉式，双重校验，枚举，静态内部类等方式实现单例。立即下载

【Java进阶营】Java设计模式－单例模式：单例的六种实现

单例模式的定义

单例模式的实现

普通饿汉式

线程不安全的懒汉式

同步锁懒汉式

双重校验锁懒汉式

静态内部类懒汉式

枚举类饿汉式（防止反序列化）

单例模式的优缺点

优点

缺点

相关推荐