java 单例的实例的几种方式

Java中的单例模式是一种设计模式，它确保一个类在全局范围内只有一个实例，并提供一个全局访问点来获取这个唯一的实例。下面是一些实现单例模式的常见方法：

1. 饿汉式（静态常量）

Java

1public class Singleton {
2    // 创建 Singleton 类的一个对象
3    private static final Singleton INSTANCE = new Singleton();
4
5    // 让构造函数为 private，这样该类就不会被实例化
6    private Singleton() {}
7
8    // 获取唯一可用的对象
9    public static Singleton getInstance() {
10        return INSTANCE;
11    }
12}

这种方式是在类加载时就完成了初始化，所以是线程安全的。

2. 饿汉式（静态代码块）

与上面类似，只是将实例化部分放在静态代码块中，确保在类加载时初始化。

Java   

1public class Singleton {
2    private static Singleton instance;
3    static {
4        instance = new Singleton();
5    }
6
7    private Singleton() {}
8
9    public static Singleton getInstance() {
10        return instance;
11    }
12}

3. 懒汉式（线程不安全）
Java
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton(); // 线程不安全
        }
        return instance;
    }
}
这种实现方式在多线程环境下可能会创建多个实例，因为它没有进行同步处理。

4. 双重检查锁定（DCL - Double-Checked Locking）

Java

1public class Singleton {
2    private volatile static Singleton singleton;
3    private Singleton() {}
4
5    public static Singleton getSingleton() {
6        if (singleton == null) { 
7            synchronized (Singleton.class) {
8                if (singleton == null) {
9                    singleton = new Singleton();
10                }
11            }
12        }
13        return singleton;
14    }
15}

双重检查锁定通过两次检查 singleton 是否为null，只有当第一次检查发现为null并进入同步代码块时，才会进行实例化操作，从而避免了多线程环境下的重复初始化问题。

5. 静态内部类

Java

1public class Singleton {
2    private Singleton() {}
3
4    private static class SingletonHolder {
5        private static final Singleton INSTANCE = new Singleton();
6    }
7
8    public static Singleton getInstance() {
9        return SingletonHolder.INSTANCE;
10    }
11}

静态内部类的方式利用了类加载机制保证了线程安全性，且延迟了初始化，既实现了懒加载又保证了线程安全。

以上就是在Java中实现单例模式的一些经典方法，每种方法都有其适用场景和优缺点，在实际应用中需根据需求选择合适的方法。