彻底玩转单例模式

野性酷女 2022-12-28 04:11 112阅读 0赞

## 单例模式 ##

> **饿汉式**

// 单例模式-饿汉式
    // 缺点：在类加载时就new出了对象，可能造成浪费空间
    public class Hungry { 
        private final static Hungry eHanDemo = new Hungry();
    
        private Hungry(){ 
        }
    
        public static Hungry getInstance(){ 
            return eHanDemo;
        }
    }

> **懒汉式**

// 懒汉式：当需要用这个对象时，再进行创建
    // 这样创建懒汉式存在问题：由于新建对象时不是原子操作，当多个线程同时需要创建对象，可能出现创建出多个对象。
    public class LazyManDemo01 { 
    
        private static LazyManDemo01 lazyManDemo01;
    
        private LazyManDemo01() { 
        }
    
        public static LazyManDemo01 getInstance() { 
            if (lazyManDemo01 == null) { 
                lazyManDemo01 = new LazyManDemo01();
            }
            return lazyManDemo01;
        }
    }

> **DCL懒汉式**，防止多线程情况下创建出多个对象问题

// DCL懒汉式，可防止多线程情况下创建多个对象
    // 问题，当通过反射方式镜像创建对象时，还是可以创建多个对象。
    public class LazyManDemo02 { 
    
        private volatile static LazyManDemo02 lazyManDemo02;
    
        private LazyManDemo02() { 
        }
    
        // 双重检测锁模式的 懒汉式单例 DCL懒汉式
        public static LazyManDemo02 getInstance() { 
            if (lazyManDemo02 == null) { 
                synchronized (LazyManDemo02.class) { 
                    if (lazyManDemo02 == null) { 
                        lazyManDemo02 = new LazyManDemo02();    // 不是原子操作
                        /** * 1. 分配内存空间 * 2. 执行构造方法，初始化对象 * 3. 把这个对象指向这个空间 * 防止指令重排，用 volatile 修饰 lazyManDemo02 */
                    }
                }
            }
            return lazyManDemo02;
        }
    
        // 反射！
        public static void main(String[] args) throws Exception { 
            // LazyManDemo02 instance = LazyManDemo02.getInstance();
    
            Constructor<LazyManDemo02> declaredConstructor = LazyManDemo02.class.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            LazyManDemo02 lazyManDemo02 = declaredConstructor.newInstance();
            LazyManDemo02 lazyManDemo022 = declaredConstructor.newInstance();
    
            System.out.println(lazyManDemo02);
            System.out.println(lazyManDemo022);
    
        }
    }

> **设置一个flag变量，判断是否创建过对象，防止反射操作获取多个对象**  
> 但通过反射改变 flag 变量值，同样无法避免创建多个对象

// 设置一个flag变量，判断是否创建过对象，防止反射操作获取
    // 问题，但通过反射也能改变 flag 的值，从而达到创建多个对象
    public class LazyManDemo03 { 
    
        private volatile static LazyManDemo03 lazyManDemo03;
    
        private static boolean flag = false;
    
        private LazyManDemo03() { 
            synchronized (LazyManDemo03.class){ 
                if (flag == false){ 
                    flag = true;
                }else { 
                    throw new RuntimeException("不要试图使用反射破坏");
                }
            }
        }
    
        // 双重检测锁模式的 懒汉式单例 DCL懒汉式
        public static LazyManDemo03 getInstance() { 
            if (lazyManDemo03 == null) { 
                synchronized (LazyManDemo03.class) { 
                    if (lazyManDemo03 == null) { 
                        lazyManDemo03 = new LazyManDemo03();    // 不是原子操作
                    }
                }
            }
            return lazyManDemo03;
        }
    }

**通过查看反射源码发现，枚举类不能通过反射获取**![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70]  
**枚举类单例**

// enum 是一个什么？ 本身也是一个Class类 
    public enum EnumSingle {  
        INSTANCE; 
        
        public EnumSingle getInstance(){  
            return INSTANCE; 
        } 
    }

**枚举类介绍：[https://blog.csdn.net/hellojoy/article/details/79883671][https_blog.csdn.net_hellojoy_article_details_79883671]**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70]: /images/20221120/a81b86d180da4b6c9982cc321cf86bf1.png
[https_blog.csdn.net_hellojoy_article_details_79883671]: https://blog.csdn.net/hellojoy/article/details/79883671