JAVA 七种建立单例的方法

时间 2020-01-12

标签 java 建立方法栏目 Java 繁體版

原文原文链接

JAVA 七种建立单例的方法

1 饿汉式

public class Singleton1 {
    //不能延迟加载 占用内存 耗费资源
    private static Singleton1 singleton1 = new Singleton1();

    public static Singleton1 getSingleton1() {
        return singleton1;
    }
}

能够保证多个线程下惟一实例，getSingleton1 方法性能较高，可是没法进行懒加载。java

2 懒汉式

public class Singleton2 {

    //延迟加载
    // 多线程下 不安全
    private static Singleton2 singleton1 = null;

    public  Singleton2 getSingleton1() {


        if (singleton1==null){
            singleton1 = new Singleton2();
        }
        return singleton1;
    }
}

懒汉式解决了延迟加载和资源问题，可是多线程下存在线程不安全问题。安全

3 懒汉式 + 同步

public class Singleton3 {

    //延迟加载
    // 多线程下 不安全
    private static Singleton3 singleton1 = null;

    //解决延迟加载 多线程安全问题，但存在读操做，加锁问题，线程排队，写操做只有一次 获取时须要排队等候问题
    public synchronized Singleton3 getSingleton1() {

        if (singleton1==null){
            singleton1 = new Singleton3();
        }
        return singleton1;
    }

/*
   等同方法前加锁
   public static Singleton3 getSingleton1() {
        synchronized(Singleton3.class){
            if (singleton1==null){
                singleton1 = new Singleton3();
            }
        }

        return singleton1;
    }
    */


}

解决延迟加载多线程安全问题，但存在读操做，加锁问题，线程排队，写操做(建立对象)只有一次，可是获取时须要排队等候问题多线程

4 懒汉式 + 双重检验

public class Singleton4 {

    //延迟加载
    private static Singleton4 singleton1 = null;

    // 解决 读操做 多线程状况下 排队获取问题， 可是双重校验 也存在一个问题，jvm 重排序的问题下 会存在空指针问题
    public static Singleton4 getSingleton1() {

        if (singleton1==null){
            synchronized (Singleton4.class) {
                if (singleton1 == null) {
                    singleton1 = new Singleton4();
                }
            }
        }
        return singleton1;
    }


}

解决读操做多线程状况下排队获取问题，可是双重校验也存在一个问题，jvm 重排序的问题下会存在空指针问题jvm

但存在一个问题，jvm指令重排序， JVM 的即时编译器中存在指令重排序的优化。ide

1 首先给 singleton1 分配内存
2 Singleton4 执行构造函数开辟空间
3 调用getSingleton1（）方法建立对象
JVM 的即时编译器中存在指令重排序的优化函数

理想状况下 jvm执行顺序是123 也多是 132 ，13在建立完对象后，再执行2 返回null，此时就是空指针了。性能

## 5 懒汉式 + 双重检验 + volatile测试

volatile 关键字禁止JVM编译时指令重排序优化

public class Singleton5 {

    //延迟加载
    // volatile 关键字 禁止指令重排序
    // 解决 双重校验 也存在一个问题，jvm 重排序的问题下 会存在空指针问题
    private static  volatile Singleton5 singleton1 = null;


    public static Singleton5 getSingleton1() {

        if (singleton1==null){
            synchronized (Singleton5.class) {
                if (singleton1 == null) {
                    singleton1 = new Singleton5();
                }
            }
        }
        return singleton1;
    }


}

6 静态内部类

public class Singleton6 {

    //延迟加载
    //静态内部类 静态的始终在jvm中存在一份
    static class Singleton {
        private static Singleton6  singleton1  = new Singleton6();
    }


    public static Singleton6 get(){
        return Singleton.singleton1;
    }
}

7 枚举

public class Singleton7 {

    //枚举类型是 线程安全 构造方法只会被装载一次
    private enum Singleton {
        Singleton;

        private final Singleton7 singleton7;


        Singleton() {
            singleton7 = new Singleton7();
        }


        public Singleton7 getSingleton7() {
            return singleton7;
        }

    }

    //延迟加载
    public static Singleton7 get() {
        return Singleton.Singleton.getSingleton7();
    }


    //测试
    public static void main(String[] args) {

        IntStream.rangeClosed(1, 100).forEach(i -> {
            new Thread(String.valueOf(i)) {
                @Override
                public void run() {
                    System.out.println(Singleton7.get());
                }
            }.start();
        });

    }
}

枚举类型不容许被继承，但线程是安全的，只能被实例化一次，可是枚举类型不可以懒加载，和方法配合使用，调用get()静态方法，而后singleton7会延迟加载获得实例化。线程