单例模式怎么实现

单例模式的实现一般有两种方式：饿汉式和懒汉式。

### 饿汉式

饿汉式是在类加载时就创建了实例，因此线程安全，但是可能会浪费内存资源。实现方式如下：

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

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

在这种实现方式中，私有的构造方法保证了外部无法通过 `new` 关键字来创建实例。`instance` 变量是类的唯一实例，它在类加载时就被创建。`getInstance` 方法返回这个唯一的实例。

### 懒汉式

懒汉式是在第一次使用时才创建实例，因此可以节约内存资源，但是需要考虑线程安全和性能问题。以下是一个线程不安全的懒汉式实现：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

在这种实现方式中，`getInstance` 方法返回 `instance` 变量，如果它还没有被创建，就会创建一个新的实例。但是该实现是线程不安全的，因为在多线程情况下，可能会创建多个实例。

为了解决线程安全问题，可以在 `getInstance` 方法上加锁：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

加锁可以保证在多线程情况下只创建一个实例，但是会影响性能。为了解决性能问题，可以使用双重检查锁定：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

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

双重检查锁定可以在保证线程安全的同时，减少锁竞争，提高性能。`volatile` 关键字保证了 `instance` 变量的可见性，防止了指令重排序问题。

总之，单例模式的实现需要考虑线程安全和性能问题，具体实现方式可以根据实际情况进行选择。