第二篇、单例模式详解（七种）

Bertha 。 2022-03-02 15:14 148阅读 0赞

## 一、单例模式定义： ##

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

## 二、单例模式特点 ##

1、单例类只能有一个实例。  
2、单例类必须自己创建自己的唯一实例。  
3、单例类必须给所有其他对象提供这一实例。

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

## 三、线程安全的问题 ##

一方面在获取单例的时候，要保证不能产生多个实例对象，后面会详细讲到五种实现方式；

另一方面，在使用单例对象的时候，要注意单例对象内的实例变量是会被多线程共享的，推荐使用无状态的对象，不会因为多个线程的交替调度而破坏自身状态导致线程安全问题，比如我们常用的VO，DTO等（局部变量是在用户栈中的，而且用户栈本身就是线程私有的内存区域，所以不存在线程安全问题）。

## 四、实现单例模式的方式 ##

**1.饿汉式单例（立即加载方式）**

//饿汉式单例
    public class Hungry {
    
        private Hungry(){}
        //先静态、后动态
        //先属性、后方法
        //先上后下
        private static final Hungry hungry = new Hungry();
    
        public static Hungry getInstance(){
    //        Hungry hungry;
    
            return  hungry;
        }
    
    }

它是在类加载的时候就立即初始化，并且创建单例对象

优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好

缺点：类加载的时候就初始化，不管你用还是不用，我都占着空间，浪费了内存，有可能占着茅坑不拉屎

绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题

**2、懒汉式单例（延迟加载方式）**

第一种：存在线程安全问题

//懒汉式单例
    //在外部需要使用的时候才进行实例化
    public class LazyOne {
        private LazyOne(){}
    
        //静态块，公共内存区域
        private static LazyOne lazy = null;
    
        public static LazyOne getInstance(){
    
            //调用方法之前，先判断
            //如果没有初始化，将其进行初始化,并且赋值
            //将该实例缓存好
            if(lazy == null){
                //两个线程都会进入这个if里面
                lazy = new LazyOne();
            }
            //如果已经初始化，直接返回之前已经保存好的结果
    
            return lazy;
    
        }
    
    }

第二种：存在性能问题

public class LazyTwo {
    
        private LazyTwo(){}
    
        private static LazyTwo lazy = null;
    
        public static synchronized LazyTwo getInstance(){
    
            if(lazy == null){
                lazy = new LazyTwo();
            }
            return lazy;
    
        }
    
    }

**3.静态内部类实现**

public class AA {
        //默认使用LazyThree的时候，会先初始化内部类
        //如果没使用的话，内部类是不加载的
    
        private AA(){
    
            synchronized (LazyThree.class){
                if(LazyHolder.initialized == false){
                    LazyHolder.initialized = !LazyHolder.initialized;
                }else{
                    throw new RuntimeException("单例已被侵犯");
                }
            }
    
        }
    
    
        //每一个关键字都不是多余的
        //static 是为了使单例的空间共享
        //保证这个方法不会被重写，重载
        public static final AA getInstance(){
            //在返回结果以前，一定会先加载内部类
            return LazyHolder.LAZY;
        }
    
    
        //默认不加载
        private static class LazyHolder{
            private static boolean initialized = false;
            private static final AA LAZY = new AA();
        }
    
    }

特点：在外部类被调用的时候内部类才会被加载，内部类一定是要在方法调用之前初始化  
巧妙地避免了线程安全问题，这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题  
完美地屏蔽了这两个缺点，

内部类需要注意序列化问题

**4.static静态代码块实现**

public class Singleton6 {
        
        // 私有构造
        private Singleton6() {}
        
        private static Singleton6 single = null;
    
        // 静态代码块
        static{
            single = new Singleton6();
        }
        
        public static Singleton6 getInstance() {
            return single;
        }
    }

**5.内部枚举类实现**

public class SingletonFactory {
        
        // 内部枚举类
        private enum EnmuSingleton{
            Singleton;
            private Singleton8 singleton;
            
            //枚举类的构造方法在类加载是被实例化 
            private EnmuSingleton(){
                singleton = new Singleton8();
            }
            public Singleton8 getInstance(){
                return singleton;
            }
        }
        public static Singleton8 getInstance() {
            return EnmuSingleton.Singleton.getInstance();
        }
    }
    
    class Singleton8{
        public Singleton8(){}
    }

**6、注册式单例实现**

//Spring中的做法，就是用这种注册式单例
    public class BeanFactory {
    
        private BeanFactory(){}
    
        //线程安全
        private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
    
        public static Object getBean(String className){
    
            if(!ioc.containsKey(className)){
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className,obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            }else{
                return ioc.get(className);
            }
    
        }
    
    
    }

**7、序列化单例实现**

//反序列化时导致单例破坏
    public class Seriable implements Serializable {
    
    
        //序列化就是说把内存中的状态通过转换成字节码的形式
        //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
        //内存中状态给永久保存下来了
    
        //反序列化
        //讲已经持久化的字节码内容，转换为IO流
        //通过IO流的读取，进而将读取的内容转换为Java对象
        //在转换过程中会重新创建对象new
    
    
        public  final static Seriable INSTANCE = new Seriable();
        private Seriable(){}
    
        public static  Seriable getInstance(){
            return INSTANCE;
        }
    
        //jvm  序列化协议  默认调用此方法
        private  Object readResolve(){
            return  INSTANCE;
        }
    
    }