1、设计模式(创建型)：之单例模式

缺乏、安全感 2022-05-14 06:49 186阅读 0赞

### 作用 ###

*  保证一个类只有一个对象，并且提供一个访问改实例的全局访问点

### 优点 ###

1.  在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）
2.  避免对资源的多重占用（比如写文件操作）

### 何时使用 ###

*  当您想控制实例数目，节省系统资源的时候

### 常见应用场景 ###

1.  Windows的Task Menager
2.  windows的Recycle Bin(回收站)
3.  项目中读取配置的类，每次只能new一个区读外部配置
4.  网站的访问情况，比如统计人数
5.  数据库连接池

### 实例 ###

1.  主要
    
    --------------------
    
    饿汉式(线程安全，调用效率高，不能延时加载)
    
        package xin.chen.create_type.singleton;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 测试饿汉式(很饿，马上就弄吃的)
         */
        public class SingletonDemo1 {
        
            /** 类初始化的时候就 立即加载这个类 */
            private static SingletonDemo1 instance = new SingletonDemo1();
        
            /** 私有化构造器，不让new */
            private SingletonDemo1(){
            }
        
            /** 提供一个静态的公共的调用实例的方法，没有同步，调用效率高 */
            public static SingletonDemo1 getInstance(){
                return instance;
            }
        }
    
      
    懒汉式(线程安全，调用效率不高，可以延时加载)  
     
    
        package xin.chen.create_type.singleton;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 测试懒汉式(很懒，需要的时候就弄池的)
         */
        public class SingletonDemo2 {
        
            /** 类初始化的时候就 不初始化这个对象 */
            private static SingletonDemo2 instance;
        
            /** 私有化构造器，不让new */
            private SingletonDemo2(){
            }
        
            /** 提供一个静态的公共的调用实例的方法，有同步，调用效率低 */
            public static synchronized SingletonDemo2 getInstance(){
                if(instance == null){
                    instance = new SingletonDemo2();
                }
                return instance;
            }
        }
    
     
2.  其他
    
    --------------------
    
    双重检测锁式(由于JVM底层内部模式原因，偶尔会出现问题，不建议使用)
    
        package xin.chen.create_type.singleton;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 测试双重检测锁 懒加载
         */
        public class SingletonDemo3 {
        
            /** 类初始化的时候就 不初始化这个对象 */
            private static SingletonDemo3 instance;
        
            /** 私有化构造器，不让new */
            private SingletonDemo3(){
            }
        
            /** 提供一个静态的公共的调用实例的方法，第一次调用同步，调用效率高，懒汉式 */
            public static SingletonDemo3 getInstance(){
                if(instance == null){
                    SingletonDemo3 sc;
                    synchronized (SingletonDemo3.class){
                        sc = instance;
                    }
                    if (sc == null) {
                        synchronized (SingletonDemo3.class){
                            if(sc == null){
                                sc = new SingletonDemo3();
                            }
                        }
                        instance = sc;
                    }
                }
                return instance;
            }
        }
    
      
    静态内部式(线程安全，调用效率高，可以延时加载)  
     
    
        package xin.chen.create_type.singleton;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 静态内部内 线程安全 调用效率高 延时加载
         */
        public class SingletonDemo4 {
        
            private static class SingletonClassInstance {
                private static final SingletonDemo4 instance = new SingletonDemo4();
            };
        
            /** 私有化构造器，不让new */
            private SingletonDemo4(){
            }
        
            /** 提供一个静态的公共的调用实例的方法 */
            public static SingletonDemo4 getInstance(){
                return SingletonClassInstance.instance;
            }
        }
    
      
    枚举式(线程安全，调用效率高，不能延时加载  
     
    
        package xin.chen.create_type.singleton;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 枚举 最好的一个，没有延时加载机制 无法被反射破解
         */
        public enum  SingletonDemo5 {
        
            INSTANCE;
        
            public void singletonOperation(){
                //其他操作
            }
        
        }
    
        附加：懒汉式(如何防止反射和序列化漏洞)
    
        package xin.chen.create_type.singleton;
        
        import java.io.Serializable;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/8/2 14:54
         * @Version:
         * @Acton: 测试懒汉式(如何防止反射和序列化漏洞)
         */
        public class SingletonDemo6 implements Serializable {
        
            /** 类初始化的时候就 不初始化这个对象 */
            private static SingletonDemo6 instance;
        
            /** 私有化构造器，不让new */
            private SingletonDemo6(){
                //通过抛异常防范反射
                if(instance != null){
                    throw new RuntimeException();
                }
            }
        
            /** 提供一个静态的公共的调用实例的方法，有同步，调用效率低 */
            public static synchronized SingletonDemo6 getInstance(){
                if(instance == null){
                    instance = new SingletonDemo6();
                }
                return instance;
            }
        
            //破解反序列化
            private Object readResolve(){
                return instance;
            }
        }

### 创建三步曲 ###

1.  私有的静态创建实例
2.  私有的构造器
3.  向外部提供一个共有的静态的获取实例的方法