设计模式01-单例模式

1.饿汉式(线程安全，调用效率高，不能延时加载)

package com.visi.dp.single;

/**
 * 饿汉式(线程安全，调用效率高，不能延时加载)
 */
public class SingletonDemo1 {
    //缺点:类开辟初始化内存数据，如果不调用getInstance这块内存就浪费掉了。（优化目标，在调用getInstance方法时才去加载这块数据）
    /*private byte[] byte1 = new byte[1024];
    private byte[] byte2 = new byte[1024];
    private byte[] byte3 = new byte[1024];
    private byte[] byte4 = new byte[1024];
*/


    //1、私有化构造器
    private SingletonDemo1(){}
    //2.初始化的时候，立即加载该对象
    private static  SingletonDemo1 instance = new SingletonDemo1();
    //3.提供获取该对象的方法，没有synchronized,效率高
    public static SingletonDemo1 getInstance(){
        return instance;
    }
}
class SingeltonDemo1Test{
    public static void main(String[] args) {
        SingletonDemo1 instance1 = SingletonDemo1.getInstance();
        SingletonDemo1 instance2 = SingletonDemo1.getInstance();
        System.out.println(instance1 == instance2); //true

    }
}

2.懒汉式（线程安全，调用效率低，可以延时加载）

package com.visi.dp.single;

/**
 * 懒汉式（线程安全，调用效率低，可以延时加载）
 */
public class SingletonDemo2 {
    //1.私有化构造方法
    private SingletonDemo2(){}
    //2.类初始化时，不立即加载对象
    private static SingletonDemo2 instance;
    //3.提供获取对象的方法，有synchronized,调用效率低
    public static synchronized SingletonDemo2 getInstance(){
        if(instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }

}
class SingletonDemo2Test{
    public static void main(String[] args) {
        SingletonDemo2 instance = SingletonDemo2.getInstance();
        SingletonDemo2 instance2 = SingletonDemo2.getInstance();
        System.out.println(instance == instance2);//true
    }

}

3.DCL（双重检查）懒汉式（线程安全，调用效率低，可以延时加载）由于JVM底层内部模型原因，偶尔会出现问题，不建议使用

package com.visi.dp.single;

/**
 * DCL（双重检查）懒汉式（线程安全，调用效率低，可以延时加载）
 * 由于JVM底层内部模型原因，偶尔会出现问题，不建议使用
 */
public class SingletonDemo3 {
    //1.私有化构造方法
    private SingletonDemo3(){}
    //2.类初始化时，不立即加载对象
    private static volatile SingletonDemo3 instance;
    //3.提供获取对象的方法，有synchronized,调用效率低
    public static SingletonDemo3 getInstance(){
        if(instance==null){
            synchronized (SingletonDemo3.class){
                instance = new SingletonDemo3();
            }

        }
        return instance;
    }

}
class SingletonDemo3Test {
    public static void main(String[] args) {
        SingletonDemo3 instance = SingletonDemo3.getInstance();
        SingletonDemo3 instance2 = SingletonDemo3.getInstance();
        System.out.println(instance == instance2);//true
    }
}

4.饿汉式改进（静态内部类,线程安全，调用效率高，可以延时加载）

package com.visi.dp.single;

/**
 * 饿汉式改进（静态内部类,线程安全，调用效率高，可以延时加载）
 */
public class SingletonDemo4 {
    //1.私有化构造方法
    private SingletonDemo4(){}
    private static class InnerClass{
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }
    //在调用getInstance时才会初始化SingeletonDemo4
    public static SingletonDemo4 getInstance(){
        return InnerClass.instance;
    }
}

class SingletonDemo4Test {
    public static void main(String[] args) {
        SingletonDemo4 instance = SingletonDemo4.getInstance();
        SingletonDemo4 instance2 = SingletonDemo4.getInstance();
        System.out.println(instance == instance2);//true
    }
}

5.枚举单例（线程安全，调用效率高，不能延时加载）

package com.visi.dp.single;
/**
 * 枚举单例（线程安全，调用效率高，不能延时加载）
 */
public enum SingletonDemo5 {
    INSTANCE;
    public SingletonDemo5 getInstance(){
        return INSTANCE;
    }
}
class SingletonDemo5Test{
    public static void main(String[] args) {
        SingletonDemo5 instance = SingletonDemo5.INSTANCE;
        SingletonDemo5 instance2 = SingletonDemo5.INSTANCE;
        System.out.println(instance == instance2);//true
    }

}