java实现单例模式的四种方式

1.饿汉模式

public class Singleton1 {

    private static Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return instance;
    }

    /**
     * 饿汉模式，线程安全，但是不能延时加载，如果资源不被调用，那么就会浪费
     */
}
           

2.懒汉式

public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance != null) {
            instance = new Singleton2();
        }
        return instance;
    }
    /**
     * 懒汉式，线程安全，可以延时加载，但是不能解决编译器优化导致的实例未初始化问题
     */
}

           

3.双重锁判断

public class Singleton3 {

    private static Singleton3 instance;

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        if (instance != null) {
            synchronized (Singleton3.class) {
                if (instance != null) {
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
    /**
     * 双重锁判断，JVM优化导致new操作的三个步骤（如下所示）可能会乱序，
     * 从而在并发场景下拿到未初始化的实例
     * 
     *  1.分配一块内存M
     *  2.在M上初始化Singleton3对象
     *  3.将M的地址估值给instance变量
     *
     *  JVM可能会让2和3交换顺序，这样就导致了未初始化
     */
}
           

4.静态内部类

public class Singleton4 {

    private Singleton4() {
    }

    private static class Singleton4InstanceClass {
        private static final Singleton4 instance = new Singleton4();
    }

    public static Singleton4 getInstance() {
        return Singleton4InstanceClass.instance;
    }
    /**
     * 采用静态内部类的形式就相当于是饿汉模式的改进，将不能延时加载的缺点处理掉了，
     * 所以该模式线程安全，调用效率高，可以延时加载
     */
}
           

5.使用

• 单例对象 占用资源少，不需要延时加载，饿汉
• 单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式