设计模式一(单例模式)

主要思路:将构造方法私有化,并对外提供一个static的方法来创建对象

饿汉式单例

java 复制代码
public class Hungry {
​
    private Hungry(){
​
    }
    private final static Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
​
    public static void main(String[] args) {
        Hungry hungry1 = Hungry.getInstance();
        Hungry hungry2 = hungry.getInstance();
        System.out.println(hungry1==hungry2);//true
    }
}

缺点:一开始就创建对象,占用系统资源

懒汉式单例

java 复制代码
public class Lazy {
​
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
​
    private static Lazy lazy;
​
    public static Lazy getInstance(){
        if(lazy==null){
            lazy = new Lazy();
        }
        return lazy;
    }
​
    public static void main(String[] args) {
       for(int i=0;i<10;i++){
           new Thread(()->{
               Lazy.getInstance();
           }).start();
       }
    }
}
​

单线程下不会出现问题,但多线程会会有并发问题,main方法的测试结果:

java 复制代码
Thread-0ok
Thread-2ok
Thread-3ok

会发生同一时间创建了多个对象,所以出现了DCL双重检索

DCL懒汉式

java 复制代码
public class Lazy {
​
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
​
    private volatile static Lazy lazy; //volatile保证不会出现代码重排
​
    public static Lazy getInstance(){
        if(lazy==null) {
            synchronized (Lazy.class) {
                if (lazy == null) {
                    lazy = new Lazy();
                    /*
                        这个过程不是一个原子性,会出现代码重排现象
                        1.开配空间
                        2.执行构造方法
                        3.引用执行
                     */
                }
            }
        }
        return lazy;
    }
​
    public static void main(String[] args) {
       for(int i=0;i<10;i++){
           new Thread(()->{
               Lazy.getInstance();
           }).start();
       }
    }
}

可以实现延迟实例化,并且是线程安全的

静态内部类

java 复制代码
public class Holder {
    private Holder(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
​
    public static Holder getInstance(){
        return InnerClass.holder;
    }
​
    public static class InnerClass{
        private static final Holder holder = new Holder();
    }
​
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Holder.getInstance();
            }).start();
        }
    }
}

反射破解单例模式

可以采用额外的变量进行控制,防止反射

java 复制代码
public class Lazy {
​
    private Lazy(){
        synchronized (Lazy.class){
            if(temp == false){
                temp = true;
            }else{
                throw new RuntimeException("不要用反射破坏单例");
            }
        }
    }
​
    private volatile static Lazy lazy; //volatile保证不会出现代码重排
​
    public static Lazy getInstance(){
        if(lazy==null) {
            synchronized (Lazy.class) {
                if (lazy == null) {
                    lazy = new Lazy();
                    /*
                        这个过程不是一个原子性,会出现代码重排现象
                        1.开配空间
                        2.执行构造方法
                        3.引用指向
                     */
                }
            }
        }
        return lazy;
    }
​
    public static void main(String[] args) throws Exception {
        Lazy lazy = Lazy.getInstance();
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        Lazy lazy1 = declaredConstructor.newInstance();
        System.out.println(lazy==lazy1);
    }
}

枚举单例

防止反射破坏

java 复制代码
public enum EnumSingleton {
    INSTANCE;
    private EnumSingleton() {
​
    }
​
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
​
    public static void main(String[] args) throws Exception {
        EnumSingleton instance = EnumSingleton.INSTANCE;
        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingleton instance1 = declaredConstructor.newInstance();
        System.out.println(instance==instance1);
    }
}

防止反序列化破坏

重写readResolve()方法

java 复制代码
private Object readResolve() throws ObjectStreamException{
        return singleton;
}
相关推荐
LoveXming3 小时前
Chapter4—工厂方法模式
c++·设计模式·简单工厂模式·工厂方法模式·开闭原则
叫我龙翔5 小时前
【设计模式】从游戏角度开始了解设计模式 --- 抽象工厂模式
c++·游戏·设计模式
馨谙8 小时前
设计模式之单例模式大全---java实现
java·单例模式·设计模式
Buling_01 天前
游戏中的设计模式——第三篇 简单工厂模式
游戏·设计模式·简单工厂模式
饭碗的彼岸one1 天前
C++设计模式之单例模式
c语言·开发语言·c++·单例模式·设计模式·饿汉模式·懒汉模式
麦当_1 天前
TanStack Router File-Based Router Mask 完全指南
前端·javascript·设计模式
烛阴1 天前
【TS 设计模式完全指南】用适配器模式优雅地“兼容”一切
javascript·设计模式·typescript
青草地溪水旁1 天前
23 种设计模式
开发语言·c++·设计模式
JohnYan1 天前
工作笔记 - 一个浏览器环境适用的类型转换工具
javascript·后端·设计模式
new_daimond1 天前
牛刀小试之设计模式
设计模式