设计模式-单例模式

• 饿汉式：类初始化就生成，线程安全

/**
 * @DESCRIPTION:
 * @Author: WangLt
 * @Date: 2020/9/25
 */
public class HungerSingle {

    public static final  HungerSingle INSTANCE = new HungerSingle();

    private HungerSingle(){

    }

    public static HungerSingle getInstance(){
        return INSTANCE;
    }

}

• 懒汉式 在调用时才创建实例

package _00_single_pattern;

/**
 * @DESCRIPTION:
 * @Author: WangLt
 * @Date: 2020/9/25
 */
public class LazySingle {

    private static volatile LazySingle instance;

    private LazySingle() {

    }

//    //线程不安全
//    public static LazySingle getInstance(){
//        if(instance == null){
//            try {
//                Thread.sleep(10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            instance =  new LazySingle();
//        }
//        return instance;
//    }

//    //改进一:直接方法synchronized 安全但效率很低，为空不为空都要等着
//    public static synchronized LazySingle getInstance(){
//        if(instance == null){
//            try {
//                Thread.sleep(10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            instance =  new LazySingle();
//        }
//        return instance;
//    }

//    //改进二:new方法synchronized 效率提高一些，只有为空的要等 但不安全
//    public static LazySingle getInstance(){
//        if(instance == null){ //此处不安全
//            synchronized(LazySingle.class){
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                instance =  new LazySingle();
//            }
//        }
//        return instance;
//    }

//    //改进三:（DCL 双重检测锁） new方法synchronized 为了安全 两次判空-->双重检查,但有指令重排的问题（该方式会导致取到一个无效或错误状态的对象：指向的地址指向分配地址，但对象还未初始化的 ）
//    public static LazySingle getInstance(){
//        if(instance == null){
//            synchronized(LazySingle.class){
//                if(instance == null){
//                    try {
//                        Thread.sleep(10);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    instance =  new LazySingle();
//                }
//            }
//        }
//        return instance;
//    }

    //改进四:new方法synchronized 双重检查 变量加volatile
    public static LazySingle getInstance(){
        if(instance == null){
            synchronized(LazySingle.class){
                if(instance == null){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance =  new LazySingle();
                }
            }
        }
        return instance;
    }


    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(LazySingle.getInstance());
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(LazySingle.getInstance());
                }
            }).start();
        }
    }
}

• 懒汉式 内部类

/**
 * @DESCRIPTION: 采用内部类实现懒加载
 * @Author: WangLt
 * @Date: 2020/9/25
 */
public class LazySingle_InnerClass {

    private LazySingle_InnerClass(){

    }

    private static class InnerHelp {
        private final static LazySingle_InnerClass INSTANCE = new LazySingle_InnerClass();
    }

    public static LazySingle_InnerClass getInstance(){
        return InnerHelp.INSTANCE;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 50; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(LazySingle_InnerClass.getInstance());
                }
            }).start();


            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(LazySingle_InnerClass.getInstance());
                }
            }).start();
        }
    }
}

核心点：构造方法私有化或者内部类进行，保证外部类无法直接调用。

---

欢迎大家评论哟！如果本文对您有帮助，请点个赞，您的点赞对我很重要！这次一定！感谢！！！
转发请注明出处呦！感谢！！！