Java 中单例类的嵌套初始化

2025年6月19日 | 阅读 4 分钟

嵌套初始化是 Java 中用于实现单例类的一种技术，单例类是指在任何给定时间只允许存在一个实例的类。嵌套初始化技术可以确保即使多个线程尝试创建单例类实例，也只创建一个实例。

嵌套初始化技术是在单例类内部创建一个嵌套类。在嵌套类内部，有一个静态变量，它作为单例类实例的容器。当嵌套类首次创建时，它将静态变量初始化为一个新的单例类实例。这确保了只生成一个单例类实例。

要在 Java 中实现嵌套初始化的单例类，必须遵循以下步骤：

将类的构造函数设为私有。通过使用嵌套初始化，其他类将被阻止直接创建单例类的实例。
在单例类内部创建一个嵌套类。该嵌套类将负责保存单例实例。
在嵌套类的静态初始化块中初始化单例实例。Java 中的嵌套初始化技术可确保在嵌套类加载期间仅创建一次单例类的实例。这可以阻止创建多个实例。
构建一个公共的静态方法，该方法返回单例实例。其他类将使用该方法来访问单例实例。

使用嵌套初始化演示单例类

文件名： Singleton.java

public class Singleton {
    // Static nested class to hold the singleton instance
    private static class Nested {
        static Singleton instance = new Singleton();
    }

    // Private Constructor to prevent direct instantiation
    private Singleton() {
        //Constructor is private to prevent direct instantiation.
    }

    // Static Method to retrieve the singleton instance
    public static Singleton getInstance() {
        return Nested.instance;
    }

    //Method to perform some action
    public void doSomething() {
        System.out.println("Hello World!");
    }

    // Main Method to demonstrate the singleton usage
    public static void main(String[] args) {
        // Get the singleton instance.
        Singleton singleton = Singleton.getInstance();

        // Do something with the singleton instance.
        singleton.doSomething();
    }
}

输出

Hello World!

嵌套初始化的优点

延迟加载
线程安全

延迟加载

延迟加载是一种仅在需要时才创建对象的机制。它可以提高性能，因为程序在启动时不需要执行太多工作。当第一次在单例类中使用 getInstance() 方法时，才会构造该对象。

线程安全

线程安全是多线程程序中的一个关键问题。多个线程可以执行线程安全的程序，而不会导致数据损坏或其他问题。嵌套初始化模式是线程安全的，因为无论有多少线程试图访问它，单例类对象都只创建和初始化一次。

单例类的非线程安全实现

文件名： MySingleton.java

public class MySingleton {
  // The instance variable is volatile to ensure that all threads
  // see the most up-to-date value.
  private static volatile MySingleton instance;
  private String message;

  // Because the constructor is private, direct instantiation is not possible.
  private MySingleton() {
    // Initialize the message variable.
    message = "Hello, I am a Singleton object!";
  }

  // The Singleton instance is returned by the getInstance() method.
  // The instance is created if it does not already exist.
  public static synchronized MySingleton getInstance() {
    // Check if the instance variable is null.
    // If it is, create a new Singleton class instance.
    if (instance == null) {
      instance = new MySingleton();
    }

    // Return the instance variable.
    return instance;
  }

  // The showMessage() Method prints the message variable.
  public void showMessage() {
    System.out.println(message);
  }

  // The setMessage() Method sets the message variable.
  public void setMessage(String newMessage) {
    message = newMessage;
  }

  // The getMessage() Method returns the message variable.
  public String getMessage() {
    return message;
  }

  // The main() Method creates two instances of the Singleton class
  // and calls the showMessage() method on each instance.
  public static void main(String[] args) {
    // Create the first instance of the Singleton class.
    MySingleton singleton1 = MySingleton.getInstance();

    // Call the showMessage() method on the first instance.
    singleton1.showMessage();

    // Create the second instance of the Singleton class.
    MySingleton singleton2 = MySingleton.getInstance();

    // Call the setMessage() method on the second instance.
    singleton2.setMessage("Updated Singleton message");

    // Call the showMessage() method on the second instance.
    singleton2.showMessage();
  }
}

输出

Hello, I am a Singleton object!
Updated Singleton message

单例类的线程安全实现

文件名： NestedInitializationDemo.java

public class NestedInitializationDemo {

    public static void main(String[] args) {

        // Create multiple threads that access the Singleton class
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Singleton singleton = Singleton.getInstance();
                System.out.println("Thread 1: " + singleton.getValue());
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Singleton singleton = Singleton.getInstance();
                System.out.println("Thread 2: " + singleton.getValue());
            }
        });

        // Start the threads
        thread1.start();
        thread2.start();
    }
}

class Singleton {

    // Private Constructor to prevent direct instantiation
    private Singleton() {
        System.out.println("Singleton instance created");
    }

    // Singleton instance is stored in a static inner class.
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    // Obtain the Singleton instance.
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    // Example method to demonstrate Singleton functionality
    public String getValue() {
        return "It is a singleton value";
    }
}

输出

Singleton instance created
Thread 1: It is a singleton value
Thread 2: It is a singleton value

下一主题Java 中的对象

Java 中单例类的嵌套初始化

使用嵌套初始化演示单例类

嵌套初始化的优点

延迟加载

线程安全

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中单例类的嵌套初始化

使用嵌套初始化演示单例类

嵌套初始化的优点

延迟加载

线程安全

相关帖子

Java 中 String、StringBuffer 和 StringBuilder 的区别

使用 StringBuilder 在 Java 中反转字符串

Java 中的条件表达式中的数字提升

Infix to Postfix Java

Icon interface Java

Java 中使用 _ (下划线) 作为变量名

How to optimize string creation in Java

Java 中的 API 开发

Minimum Jumps to Reach the End Problem in Java

Java 中的隔离岛

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器