单例模式8种写法

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 16:59
 * 饿汉模式第一种(静态常量)
 *
 */
public class Singleton1 {

    private Singleton1(){}

    private static final Singleton1 singleton1=new Singleton1();

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

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:01
 *  饿汉模式第二种（静态代码块）
 */
public class Singleton2 {
    private Singleton2(){}

    private static Singleton2 singleton2;

    static {
        singleton2=new Singleton2();
    }

    public static Singleton2 getSingleton2(){
        return singleton2;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:04
 * 懒汉模式第一种
 */
public class Singleton3 {
    private Singleton3(){}

    private static Singleton3 singleton3;

    /**
     *
     *  
     * @author chip
     * @date 2020/7/10 17:14 
     * @return com.learn.design_pattern.singleton.Singleton3
     * 两个线程同时通过if判断的情况下，线程不安全
     */
    public static Singleton3 singleton3(){
        if(singleton3==null){
            singleton3=new Singleton3();
        }
        return singleton3;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:08
 * 懒汉式第二种
 */
public class Singleton4 {
    private Singleton4(){}

    private static Singleton4 singleton4;

    /**
     *
     *  
     * @author chip
     * @date 2020/7/10 17:15
     * @return com.learn.design_pattern.singleton.Singleton4
     * if判断只需进行一次就可以，之后一直锁住方法影响效率
     */
    public static synchronized Singleton4 getSingleton4(){
        if(singleton4==null){
            singleton4=new Singleton4();
        }
        return singleton4;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:17
 * 懒汉模式第三种
 */
public class Singleton5 {
    private Singleton5(){}

    private static Singleton5 singleton5;

    /**
     *
     *  
     * @author chip
     * @date 2020/7/10 17:19
     * @return com.learn.design_pattern.singleton.Singleton5
     * 两个线程同时通过if判断，即使上锁也会创建两个不同的对象，线程不安全
     */
    public static Singleton5 getSingleton5(){
        if(singleton5==null){
            synchronized (Singleton5.class){
                singleton5=new Singleton5();
            }
        }
        return singleton5;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:20
 * 双重锁校验
 */
public class Singleton6 {
    private Singleton6(){}

    private static volatile Singleton6 singleton6;
    
    /**
     *
     *  
     * @author chip
     * @date 2020/7/10 17:23 
     * @return com.learn.design_pattern.singleton.Singleton6
     * 第一个if进入后锁住对象，再进行判断，即使在多线程情况下也可保证线程同步，并且同步代码块之后都不会执行，提高效率
     */
    public static Singleton6 getSingleton6(){
        if(singleton6==null){
            synchronized (Singleton6.class){
                if(singleton6==null){
                    singleton6=new Singleton6();
                }
            }
        }
        return singleton6;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:25
 * 静态内部类
 */
public class Singleton7 {
    private Singleton7(){}


    private static class SingletonClass{
        private static final Singleton7 INSTANCE=new Singleton7();
    }  
    
    /**
     *
     *  
     * @author chip
     * @date 2020/7/10 17:30 
     * @return com.learn.design_pattern.singleton.Singleton7
     * 外部类装载化时不会装载静态内部类
     * 调用方法时才会装载静态内部类，而装载静态内部类是jdk实现的，线程安全的
     */
    public static Singleton7 getSingleton7(){
        return SingletonClass.INSTANCE;
    }
}

package com.learn.design_pattern.singleton;

/**
 * TODO
 *
 * @author chip
 * @version 1.0
 * @date 2020/7/10 17:29
 * 枚举
 */
enum  Singleton8 {
    INSTANCE;
}