Java中的单例模式大全一文掌握所有写法！

原创

疯狂的KK

发布于 2024-06-03 15:51:07

1610

发布于 2024-06-03 15:51:07

文章被收录于专栏：Java项目实战

引言

在Java的世界里，单例模式（Singleton Pattern）是一种常见的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。今天，我们将深入探讨Java中所有单例模式的写法，包括经典的懒汉式、饿汉式，以及现代的枚举式和静态内部类式。此外，我们还将手写一个线程安全的单例模式，并分析其运行原理、应用场景以及源码。如果你对设计模式感兴趣，或者正在寻找提高代码质量的秘诀，那么这篇文章绝对不容错过！

单例模式的写法

经典的懒汉式单例

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

经典的饿汉式单例

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {}

    public static HungrySingleton getInstance() {
        return instance;
    }
}

现代的枚举式单例

public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        // 实现具体逻辑
    }
}

现代的静态内部类式单例

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    private static class SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

/**
 * @author zhaokkstart
 * @create 2024-06-03 13:59
 */
public class SingletonDemo {
    private static volatile SingletonDemo instance = null;
    //构造器私有化
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName());
    }
    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class) {
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockSingleton {
    private static final Lock lock = new ReentrantLock();
    private static LockSingleton instance;

    private LockSingleton() {}

    public static LockSingleton getInstance() {
        if (instance == null) {
            lock.lock(); // 加锁
            try {
                if (instance == null) {
                    instance = new LockSingleton();
                }
            } finally {
                lock.unlock(); // 释放锁
            }
        }
        return instance;
    }
}

线程安全的单例模式

在上述写法中，经典的懒汉式单例模式是线程不安全的，因为它在多线程环境下可能会创建多个实例。而经典的饿汉式单例模式、枚举式单例和静态内部类式单例都是线程安全的。

静态内部类式单例的线程安全分析

静态内部类式单例模式利用了类加载机制的特性，确保了单例的唯一性。当外部类被加载时，静态内部类不会被加载，只有在调用getInstance()方法时，静态内部类才会被加载并初始化，此时才会创建单例对象。由于类加载是线程安全的，因此这种写法是线程安全的。

单例模式的运行原理

单例模式的运行原理主要基于类加载机制和内存模型。在Java中，类的加载是线程安全的，因此单例模式的实例化过程也是线程安全的。此外，单例模式通常会使用私有的构造函数和静态方法来控制实例的创建和访问，确保全局只有一个实例。

单例模式的应用场景

单例模式在Java中有着广泛的应用，例如：

数据库连接池
配置管理器
日志记录器
缓存管理器

这些场景通常需要全局共享一个实例，并且实例的状态需要在程序的整个生命周期内保持一致。

单例模式的源码分析

在Java的源码中，单例模式的使用也非常普遍。例如，java.lang.Runtime类就是一个典型的单例模式实现：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
}

在这个例子中，Runtime类使用了经典的饿汉式单例模式，确保了Runtime实例的唯一性。

结语

单例模式是Java设计模式中的一个基础且重要的模式。通过本文的详细介绍，你应该对Java中所有单例模式的写法、线程安全、运行原理、应用场景以及源码分析有了深入的理解。如果你觉得这篇文章对你有帮助，请不要吝啬你的点赞和评论。你的互动是我继续创作的动力！如果你有任何疑问或者想要了解更多设计模式的知识，欢迎在评论区留言，我会尽快回复你。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

设计模式