理解 Java 中的单例模式-java教程-PHP中文网

理解 Java 中的单例模式

Linda Hamilton

发布： 2025-01-24 02:25:08

原创

492 人浏览过

Understanding the Singleton Pattern in Java

Java Singleton 模式是一种广泛使用的设计模式，它保证一个类只有一个实例并为其提供全局访问点。将其视为监督团队的单一经理 - 只有一个经理，每个人都通过该单一联系点进行交互。本文将详细介绍该模式在 Java 中的实现和各种方法。

为什么使用单例模式？

保证单个实例： 确保应用程序中仅存在一个类的一个实例。这对于管理数据库连接（避免过多的连接创建和破坏）或打印机后台处理程序（防止用户之间的冲突）等资源至关重要。
全局访问点： 为实例提供单个、随时可用的访问点。
资源管理：高效管理共享资源，例如配置、日志系统或线程池。

如何在 Java 中实现单例模式

存在多种方法，每种方法都有自己的权衡：

1。延迟初始化： 仅在第一次需要时创建实例。

<code class="language-java">import java.io.Serializable;

public class LazySingleton implements Serializable {
    private static LazySingleton instance;

    private LazySingleton() {
        if (instance != null) {
            throw new IllegalStateException("Instance already created");
        }
    }

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

    private Object readResolve() {
        return getInstance();
    }
}</code>

登录后复制

2。线程安全单例： 使用 synchronized 确保实例创建过程中的线程安全。

<code class="language-java">import java.io.*;

public class ThreadSafeSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton() {
        if (instance != null) {
            throw new IllegalStateException("Instance already created");
        }
    }

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

    private Object readResolve() {
        return getInstance();
    }
}</code>

登录后复制

3。双重检查锁定：通过最小化同步开销来优化线程安全。

<code class="language-java">import java.io.*;

public class DoubleCheckedLockingSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {
        if (instance != null) {
            throw new IllegalStateException("Instance already created");
        }
    }

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }

    private Object readResolve() {
        return getInstance();
    }
}</code>

登录后复制

4。 Bill Pugh Singleton（推荐）： 使用静态内部类来确保延迟初始化和线程安全。

<code class="language-java">import java.io.*;

public class BillPughSingleton implements Serializable {
    private static final long serialVersionUID = 1L;

    private BillPughSingleton() {
        if (SingletonHelper.INSTANCE != null) {
            throw new IllegalStateException("Instance already created");
        }
    }

    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }

    private Object readResolve() {
        return getInstance();
    }
}</code>

登录后复制

5。枚举单例（现代方法）： 利用枚举固有的线程安全性和序列化处理。由于其简单性和稳健性，这通常被认为是最好的方法。

<code class="language-java">public enum EnumSingleton {
    INSTANCE;

    public void showMessage() {
        System.out.println("Hello from Enum Singleton!");
    }
}</code>

登录后复制