单例模式的5种实现方法，为你的程序保驾护航！

**1. 饿汉式** 

饿汉式就是类加载后就创建好了单例，直接拿就行，但该方法容易产生垃圾。

**2. 懒汉式** 

懒汉式就是，只有我使用的时候才去创建对象，但多线程条件下可能会破坏单例。

**3. 线程安全的懒汉式** 

为了解决懒汉式在多线程下的问题，我们可以使用synchronized对getInstance()方法进行同步，这样就可以保证只有一个线程能够访问getInstance()方法，从而保证单例的正确性。

**4. 双重锁** 

双重锁是懒汉式的一种优化，它先检查instance是否为null，如果为null，再进入同步块创建instance，如果instance不为null，则直接返回instance。这样可以减少同步块的执行次数，提高性能。

**5. 静态内部类** 

静态内部类是实现单例模式的另一种方法，它将instance声明为一个静态内部类，当外部类被加载时，静态内部类不会被加载，只有当调用getInstance()方法时，静态内部类才会被加载并创建instance，从而保证了单例的正确性。

以上就是5种实现java单例模式的方法，每种方法都有其优缺点，在实际使用中，我们可以根据具体情况选择合适的方法。

**示例代码：** 

```java
// 饿汉式
public class Singleton1 {
    private static Singleton1 instance = new Singleton1();

    private Singleton1() { }

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

// 懒汉式
public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() { }

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

// 线程安全的懒汉式
public class Singleton3 {
    private static Singleton3 instance;

    private Singleton3() { }

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

// 双重锁
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() { }

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

// 静态内部类
public class Singleton5 {
    private static class SingletonHolder {
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5() { }

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

希望这些内容能对你有所帮助。