设计模式之单例模式

Singleton（单例模式）

一、单例模式简介

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。
• 4、核心作用：保证一个类只有一个实例，并提供一个访问该实例的全局访问点。

二、单例模式优缺点比较

优点：

• 1、在内存里只有一个实例，减少了系统性能的开销，尤其是频繁的创建和销毁实例。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 1、windows任务管理器 、回收站、文件系统
• 2、加载配置文件类、日志应用
• 3、计数器
• 4、数据库连接池技术
• 5、spring Bean

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化（线程不安全）。

三、实现UML类图

 四、单例模式的实现方式

   4.1 饿汉式（线程安全、调用效率高、无延迟加载）

//饿汉式
public class SingletonDemo01 {
    
    //类加载时，天然线程安全(无延迟加载)，无synchronized修饰，效率高
    private static SingletonDemo01 s1 = new SingletonDemo01();
    
    //构造器私有
    private SingletonDemo01(){};
    
    //方法无同步，调用效率高
    public static SingletonDemo01 getInstance() {
        return s1;
    };
    
    public void showMsg() {
        System.out.println("Singleton  implement");
    }
    
    public static void main(String[] args) {
        SingletonDemo01 s1 = SingletonDemo01.getInstance();
        s1.showMsg();
    }
}

   4.2 懒汉式（线程安全、调用效率低、可延迟加载）

//懒汉式-可延迟加载 资源利用率提高
public class SingletonDemo02 {
    
    private static SingletonDemo02 instance;
    
    //构造器私有
    private SingletonDemo02() {    }
    
    //synchronized同步，执行效率低，并发效率降低（无synchronized修饰时线程不安全）
    public  static  synchronized SingletonDemo02 getInstance() {
        if(instance == null) {
            instance = new SingletonDemo02();
        }
        return instance;
    }
}

   4.3 双重检测锁式（线程安全、调用效率低、可延迟加载 DCL 即 Double-checked locking）

//双重检测锁式
public class SingletonDemo03 {
    
    private volatile static SingletonDemo03 instance;
    
    //构造器私有
    private SingletonDemo03() {}
    
    public static SingletonDemo03 getInstance() {
        if(instance == null) {
            synchronized (SingletonDemo03.class) {
                if(instance == null) {
                    instance = new SingletonDemo03();
                }
            }
        }
        return instance;
    }   
}

   4.4 静态内部类实现单例模式（线程安全、调用效率高、可延迟加载）

public class SingletonDemo04 {
    
    //定义静态内部类
    private  static class SingletonClassInstance{
        private static final  SingletonDemo04 instance = new SingletonDemo04();
    }
    
    //构造器私有
    private SingletonDemo04() {
        
    }
    
    public static SingletonDemo04 getInstance() {
        return SingletonClassInstance.instance;
    }
}

   4.5 枚举（线程安全、调用效率高、无延迟加载）

 public enum SingletonDemo05 {
     //枚举本身就是单例
     INSTANCE;
     
     //可添加其他操作
     public void test() {
     }
}

五、防止单例反射漏洞

/**
 * 除枚举类外，其他单例模式存在反射漏洞
 * 单例模式防止反射漏洞(饿汉式为例)
 */

public class SingletonDemo06 {
    
    private static SingletonDemo06 instance = new SingletonDemo06();
    //构造器私有
    private  SingletonDemo06() {
      //防止反射漏洞修复
        if(instance!=null) {
            throw new RuntimeException();
        }
    }
    
    //提供统一访问入口
    public static SingletonDemo06 getInstance() {
        return instance;
    }

}

    //防止反射漏洞测试
    @Test
    public void testReflect() throws Exception {
        SingletonDemo06 s1 = SingletonDemo06.getInstance();
        SingletonDemo06 s2 = SingletonDemo06.getInstance();
        System.out.println(s1);
        System.out.println(s2);

        @SuppressWarnings("unchecked")
        Class<SingletonDemo06> clazz = (Class<SingletonDemo06>)Class.forName("gof.com.yew.singleton.SingletonDemo06");
        Constructor<SingletonDemo06> c = clazz.getDeclaredConstructor();
        c.setAccessible(true);
        SingletonDemo06 s3 = (SingletonDemo06)c.newInstance();
        System.out.println(s3);
    }

六、防止单例反序列化漏洞

public class SingletonDemo07 implements Serializable{
    private static final long serialVersionUID = 1L;
    
    private static SingletonDemo07 instance ;
    
    private SingletonDemo07() {}
    
    public static synchronized SingletonDemo07 getInstance() {
        if(instance == null) {
            instance = new SingletonDemo07();
        }
        return instance;
    }
    
    //反序列化时直接调用该方法返回，而不需要单独再创建对象
    private Object readResolve() throws ObjectStreamException{
        return instance;
    }

}


//防止反序列化漏洞测试
        @Test
        public void testSerializablet() throws Exception {
            SingletonDemo07 s1 = SingletonDemo07.getInstance();
            SingletonDemo07 s2 = SingletonDemo07.getInstance();
            System.out.println(s1);
            System.out.println(s2);

            //写入文件
            FileOutputStream fos = new FileOutputStream("F:\\a.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s1);
            oos.close();
            fos.close();
            
            //反序列化生成对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\a.txt"));
            SingletonDemo07 s3 = (SingletonDemo07) ois.readObject();
            ois.close();
            System.out.println(s3);
        }

七、如何选用单例实现方式

单例对象、占用资源少、无需延迟加载	枚举优于饿汉式
单例对象、占用资源多、需延迟加载	静态内部类优于懒汉式
枚举可天然防止反序列化和反射的漏洞