Java常用设计模式之单例模式详解

设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

1、单例模式

什么是单例模式？

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式分为：懒汉式单例、饿汉式单例

单例模式：一个类只能有一个实例，管理器类/调度器类

实现单例模式的三个关键点

• 构造方法私有化
• 提供一个本类型的静态成员变量
• 提供一个静态的共有方法，返回值类型是本类型

单例模式特点

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

1.饿汉式单例

• 实例提前就创建好，是线程安全的
• 如果后期没有使用到这个单例模式，就会浪费内存空间

使用场景：如果此单例占用内存比较小，可以使用饿汉式单例进行创建

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

public class HungrySingleton {
    private static HungrySingleton instance = new HungrySingleton();

    private HungrySingleton(){

    }

    public static HungrySingleton getInstance(){
        return instance;
    }
}

2.懒汉式单例

1、懒汉式单例初级版本：

• 这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
• 不要求线程安全，在多线程不能正常工作。

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton(){
    }

    public static LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

2、懒汉式单例

• 使用synchronized关键字修饰静态方法，能够在多线程中很好的工作(线程安全)，但是，效率很低。

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率

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

3、双重校验锁(double check)

volatile可以防止指令重排序

如果不使用volatile关键字可能会报错，见代码注释。

• 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class LazySingleton {
 	// volatile可以防止指令重排序
    private volatile static LazySingleton instance;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        //双重检测 ，double check
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                //JVM 指令重排序; 在单线程不会有数据不一致情况
                    // 1, new 实例  10S
                    // 2，给引用赋值 2S
                    // 3，return 引用 1S  13S
                    // 231 3S 因为指令重排序的问题，在实际使用过程中会出现对象状态不正确的现象
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

单例模式的攻破

• 使用反射攻破
• 使用序列化攻破

1、使用反射攻破

代码演示：

    public static void test() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class<?> aClass = Class.forName("com.codeyancy.smp.LazySingleton");
        //得到无参构造
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        //把访问权限设为可访问
        constructor.setAccessible(true);
        Object o1 = constructor.newInstance();
        Object o2 = constructor.newInstance();
        Object o3 = constructor.newInstance();

        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
        System.out.println(o1==o2);
        System.out.println(o1==o3);
        System.out.println(o2==o3);
    }

结果：

与单例模式一个类只能有一个实例不符合！

2、使用序列化攻破

• 首先需要单例模式实现接口：public class LazySingleton implements Serializable

代码演示：

public static void main(String[] args) {

        LazySingleton instance = LazySingleton.getInstance();

        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("obj.txt"));
             ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("obj.txt"))) {
            objectOutputStream.writeObject(instance);
            Object object = objectInputStream.readObject();
            
            System.out.println(object);
            System.out.println(instance);
            System.out.println(object == instance);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

结果：

与单例模式一个类只能有一个实例不符合！

使用枚举类实现单例

在effective java这本书中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。

只有一个实例，使用反射或者序列化都不能有其他实例

• 线程安全
• 这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

public enum EnumSingleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething...");
    }
}

调用方法：

public class TestEnumSingleton {

    public static void main(String[] args) {
        EnumSingleton.INSTANCE.doSomething();
    }
}

直接通过EnumSingleton.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。