java单例模式4种使用方式分享

在Java中，单例模式是一种常用的设计模式，用于确保一个类仅有一个实例，并提供一个全局访问点。以下是四种常见的单例模式实现方式：

### 1. 懒汉式（线程不安全）

public class SingletonLazyUnsafe {
    private static SingletonLazyUnsafe instance;

    private SingletonLazyUnsafe() {}

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

注意：这种方式在多线程环境下是不安全的。

### 2. 懒汉式（线程安全）

public class SingletonLazySafe {
    private static volatile SingletonLazySafe instance;

    private SingletonLazySafe() {}

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

    // 或者使用双重检查锁定（Double-Check Locking）
    // public static SingletonLazySafe getInstance() {
    //     if (instance == null) {
    //         synchronized (SingletonLazySafe.class) {
    //             if (instance == null) {
    //                 instance = new SingletonLazySafe();
    //             }
    //         }
    //     }
    //     return instance;
    // }
}

注意：这里展示了使用`synchronized`关键字和双重检查锁定的两种线程安全方式。

### 3. 饿汉式

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

    private SingletonEager() {}

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

注意：这种方式基于类加载机制避免了多线程同步问题，但是实例在类装载时就完成创建，没有达到Lazy Loading的效果。

### 4. 静态内部类

public class SingletonInnerClass {
    private SingletonInnerClass() {}

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

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

注意：这种方式利用了classloder的机制来保证初始化instance时只有一个线程，并且实现了lazy loading。

以上是Java中实现单例模式的四种常见方式。每种方式都有其适用场景和优缺点，根据实际需求选择最合适的实现方式。