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

目录

1.什么是单例模式？

2.单例模式的要素

3.恶汉式单例

4.懒汉式单例

5.如何防止指令重排？

6.如何破坏懒汉式单例与饿汉式单例？

7.枚举实现单例模式

8.全文总结

---

1.什么是单例模式？

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

2.单例模式的要素

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

3.恶汉式单例

构造器私有

在类加载时已经创建好该单例静态对象，等待被程序使用（该对象以后不在改变）

因此饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

出现的问题：浪费内存

解决方法：初始设置一些数组（但是浪费空间）

public class Hunger {
    private Hunger(){}
    private static final Hunger single = new Hunger();
    //静态方法工厂
    public static Hunger getInstance(){
        return single;
    }
}

4.懒汉式单例

在真正需要使用对象时才去创建该单例类对象

懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象。否则则先执行实例化操作

public class Lazyman {
    private static Lazyman lazyman;
    private Lazyman(){}
    public static Lazyman getInstance(){
        if (lazyman == null){
            lazyman = new Lazyman();
        }
        return lazyman;
    }
}

出现问题：如果两个线程同时判断lazyman为空，那么它们都会去实例化一个lazyman对象，这就变成双例了

优化：解决线程安全问题

在方法上加锁，或者是对类对象加锁

//此处举例在对象上加锁
public class Lazyman {
    private static Lazyman lazyman;
    private Lazyman(){}
    public static Lazyman getInstance(){  
        synchronized (Lazyman.class) {
            if (lazyman == null) {
                lazyman = new Lazyman();
            }
            return lazyman;
        }
    }
}

这样就规避了两个线程同时创建lazyman对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。

如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例,所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁

public class Lazyman {
    private static Lazyman lazyman;
    private Lazyman(){}
    public static Lazyman getInstance(){  
        if (lazyman == null){       // 线程A和线程B同时看到lazynull = null，如果不为null，则直接返回lazyman
        synchronized (Lazyman.class) {   // 线程A或线程B获得该锁进行初始化
            if (lazyman == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                lazyman = new Lazyman();
            }
        }
        }
        return lazyman;
    }
}

上面的代码已经完美地解决了并发安全+性能低效问题：

因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁）

此时还存在最后一个问题：指令重排

5.如何防止指令重排？

指令重排序是指：JVM在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能

使用volatile关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换，这样在多线程环境下就不会发生NPE异常了。

volatile还有第二个作用：使用volatile关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

最终代码

public class Lazyman {
    private static volatile Lazyman lazyman;
    private Lazyman(){}
    public static Lazyman getInstance(){
        if (lazyman == null){
        synchronized (Lazyman.class) {
            if (lazyman == null) {
                lazyman = new Lazyman();
            }
        }
        }
        return lazyman;
    }
}

6.如何破坏懒汉式单例与饿汉式单例？

无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象)

1.利用反射破坏单例模式

public class fanshepohuai {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取类的显示构造器
        Constructor<Lazyman> construct = Lazyman.class.getDeclaredConstructor();
        //可访问私有构造器
        construct.setAccessible(true);
        //利用反射构建新的对象
        Lazyman theone = construct.newInstance();
        //通过正常方式是获取单例对象
        Lazyman thetwo = Lazyman.getInstance();
        System.out.println(theone == thetwo); //false
    }
}

利用反射，强制访问类的私有构造器，去创建另一个对象

2.利用序列化与反序列化破坏单例模式

public class xuleihuapohuai {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Lazyman.file"));
        //将单例对象写入到文件中
        oos.writeObject(Lazyman.getInstance());
        //从文件中读取单例对象
        File file = new File("Lazyman");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Lazyman newInstance = (Lazyman) ois.readObject();
        //判断是否是同一个对象
        System.out.println(newInstance == Lazyman.getInstance()); //false
    }
}

两个对象地址不相等的原因是：readObject() 方法读入对象时，它必定会返回一个新的对象实例，必然指向新的内存地址

7.枚举实现单例模式

jdk1.5之后出现

public class meiju {
​
    public enum Singleton {
        INSTANCE;
​
        public void doSomething() {
            System.out.println("这是枚举类型的单例模式！");
        }
    }
}

使用枚举实现单例的优势：

• 代码对比饿汉式与懒汉式来说，更加地简洁

• 它不需要做任何额外的操作去保证对象单一性与线程安全性

• 使用枚举可以防止调用者使用反射、序列化与反序列化机制强制生成多个单例对象，破坏单例模式

枚举小总结：

（1）Enum 类内部使用Enum 类型判定防止通过反射创建多个对象

（2）Enum 类通过写出（读入）对象类型和枚举名字将对象序列化（反序列化），通过 valueOf() 方法匹配枚举名找到内存中的唯一的对象实例，防止通过反序列化构造多个对象

（3）枚举类不需要关注线程安全、破坏单例和性能问题，因为其创建对象的时机与饿汉式单例有异曲同工之妙。

8.全文总结

（1）单例模式常见的写法有两种：懒汉式、饿汉式

（2）懒汉式：在需要用到对象时才实例化对象，正确的实现方式是：Double Check + Lock，解决了并发安全和性能低下问题

（3）饿汉式：在类加载时已经创建好该单例对象，在获取单例对象时直接返回对象即可，不会存在并发安全和性能问题。

（4）在开发中如果对内存要求非常高，那么使用懒汉式写法，可以在特定时候才创建该对象；

（5）如果对内存要求不高使用饿汉式写法，因为简单不易出错，且没有任何并发安全和性能问题

（6）为了防止多线程环境下，因为指令重排序导致变量报NPE，需要在单例对象上添加volatile关键字防止指令重排序

（7）最优雅的实现方式是使用枚举，其代码精简，没有线程安全问题，且 Enum 类内部防止反射和反序列化时破坏单例。