单例模式大全，反射拆解！你面试要的8种单例都在这了

Java
201
0
0
2024-02-25
java面试之java IO
上一篇
Java–Socket编程TCP通信
下一篇
标签   Java设计模式

单例模式

单例模式：类的对象有且只有一个

首先控制对象的产生数量：将构造方法私有化(从源头控制对象数量,控制构造方法)

构造方法私有化：

  • 任何其他类均无法参生此对象(本质是任何他类均无法调用构造方法，所以无法产生对象)
  • 唯一的一个对象产生于类内部
  • 唯一的属性为<静态属性>，并且类中提供静态方法取得此对象。因为类的外部无法产生对象，因此无法调用对象方法

1. 饿汉式–静态常量

饿汉式单例，顾名思义，就是很饥渴，一上来就new产生 实例化 对象

 /**
 * 饿汉式三个核心组成
 *.构造方法私有化
 *.类内部提供静态私有域
 *.类内部提供静态方法返回唯一对象
 */
class Singletons {
    //唯一的对象在类加载时产生
    private final static  single tons single = new Singletons();

    //构造方法私有化

    private Singletons() { }

    //静态方法-----为什么是静态方法？？
    //因为在类的外部无法产生对象，因此无法调用对象方法
    //通过getter方法取得唯一的对象
    public static Singletons  getInstance (){
        return single;
    }

    public void print() {
        System.out.println("饿汉式单例,上来直接new……");
    }
}

public class HungrySingleton {
    public static void main(String[] args) {
        //不能直接new,而是通过 Singleton.getInstance()静态方法取得类中已经产生好的对象
        Singletons single = Singletons.getInstance();
        Singletons single = Singletons.getInstance();
        System.out.println(single == single);
        single.print();
    }

饿汉式单例 (静态常量)

【优点】 ：书写简单，类加载时就完成了实例化，避免了 线程 同步问题

【缺点】 ：在类加载就完成实力化，没有达到懒加载的效果。如果从始至终没有使用过这个实例对象，会造成内存浪费

【总结】： 可用，但是可能会造成内存资源的浪费

2. 饿汉式–静态代码块

 class Singleton {
    private static Singleton single;

    private Singleton() { }

    static {
        single = new Singleton();
    }

    public static Singleton getInstance(){
        return single;
    }

    public void print() {
        System.out.println("饿汉式单例,静态代码块方式");
    }
}

public class HungrySingleton {
    public static void main(String[] args) {
        Singleton single = Singleton02.getInstance();
        Singleton single1 = Singleton02.getInstance();
        System.out.println(single == single);
        single.print();
    }
}

饿汉式单例 (静态代码块)

这种方式的优缺点和上面第一种静态变量的没差别，区别就是初始化的位置不同，初始化的过程放到了静态代码块。

3. 懒汉式–线程不安全

当第一次去使用Singleton对象的时候才会为其产生实例化对象

通过一个静态公有方法，当使用到该方法时，才创建对象(懒汉式)

 /**
 * @Author: Mr.Q
 * @Description:懒汉式单例---线程不安全
 * 特点: 当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作.
 */class Singleton {

    private static Singleton single;

    //private 声明无参构造
    private Singleton() { }

    //静态公有方法，当使用到该方法时，才创建对象(懒汉式)
    public static Singleton getInstance(){
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }

    public void print() {
        System.out.println("懒汉式单例(线程不安全)，用的时候再new产生对象……");
    }
}

public class LazySingleton {
    public static void main(String[] args) {
        Singleton single = Singleton.getInstance();
        Singleton single = Singleton.getInstance();
        System.out.println(single == single);
        single.print();
    }
}

懒汉式单例 (线程不安全)

【优缺点】：这种写法是存在 线程安全 问题的。类比于上面两种饿汉式单例模式，它们在没有调用时虽然会造成内存资源的浪费，但是是安全的。因为在类加载时就完成了实例化，避免了线程同步问题。

但是这种懒汉式写法，起到了懒加载效果，但是只能在单线程下使用

【线程安全问题分析】：在多线程场景下，一个线程进入了getInstance方法的if条件判断if(single == null)，还没来得及继续向下执行，另一个新进入的线程也通过了这个判断语句，这是就会产生多个实例，就不是单例的了。

所以此方法在多线程场景下不可使用。

4. 懒汉式–同步方法

既然线程不安全，那我们给他加把锁在getInstance方法上保证线程安全。

 /**
 * @Author: Mr.Q
 * @Description:懒汉式单例---同步方法(效率太低)
 */class Singleton {

    private static Singleton single;

    //private 声明无参构造
    private Singleton() { }

    //静态公有方法，当使用到该方法时，才创建对象(懒汉式)
    public  synchronized  static Singleton04 getInstance(){
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }

    public void print() {
        System.out.println("懒汉式单例(线程安全)，同步方法效率太低");
    }
}

public class LazySingleton {
    public static void main(String[] args) {
        Singleton single = Singleton04.getInstance();
        single.print();
    }
}

懒汉式单例(同步方法)

【优点】：解决了线程不安全的问题

【缺点】：效率太低。每个线程想要获取类的实例时，都要等在getInstance这个同步方法外，串型执行。但是由于是单例模式，只会产生一个实例化对象，第一个线程实例化完对象之后，后面的线程便不需要执行if的条件判断了，直接return即可，但是在进入同步方法时每次都要等待，效率太低。

5. 懒汉式–同步代码块

先来说一种错误示范：

在if条件中添加同步代码块

这段代码看起来很完美，很可惜，它是有问题。主要在于single= new Singleton()这句，这并非是一个 原子操作 。

此处由于不是原子操作，编译器可能会产生指令重排的问题，所以需要保证原子性，同时加上双重if条件判断。懒汉式 (同步代码块)正确的写法应该是 双重检查 DCL

6. 双重检查DCL

volatile 关键字修饰，轻量级锁，可以使值修改后立即更新到主存

 private volatile static SafeSingleton single = null;

【这里添加volatile的原因是】

 single = new SafeSingleton();

创建对象这条语句不是原子操作

new关键字创建对象的过程分为三步：

  • 分配内存空间；
  • 堆内存上创建对象（执行构造方法）；
  • 将对象的引用指向堆内存；

由于不是原子操作，就可能产生指令重排的问题。

步骤2和步骤3可能会被编译器指令重排，1 -> 2 -> 3的执行顺序变为了1 -> 3 -> 2

先把对象的引用指向堆空间，然后再在堆上创建对象。(理解为图书馆占座位，人还没到，但是位置上却被占用了)

判断非空，但是实际拿到的对象还未完成初始化去创建，就会出现 空指针异常 。

所以要 防止指令重排，保证有序性，及时通知其线程single的实时状态 ，就必须加上volatile关键字来防止指令重排，保证1 -> 2 -> 3的执行顺序。

 class SafeSingleton {

    //使用volatile关键字保其可见性
    private volatile static SafeSingleton single = null;

    private SafeSingleton() { }

    //同步代码块上锁
    public static SafeSingleton getInstance() {
        if(single == null) {
            synchronized (SafeSingleton.class) {
                //双重检查
                if (single == null) {
                    single = new SafeSingleton();
                }
            }
        }
        return single;
    }

    public void print() {
        System.out.println("双重检测锁的DCL单例");
    }
}

public class ReflectDCL {
    public static void main(String[] args) {
        //静态方法取得类中已经产生好的对象
        SafeSingleton single = SafeSingleton.getInstance();
        single.print();
    }
}

【双重检查分析】

  • Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(single == null)的检查，这样就可以保证线程安全了。
  • 这样，实例化代码只用执行一次，后面再次访问时，判断if(single == null)直接 return实例化对象，也避免的反复进行方法同步
  • 线程安全；延迟加载；效率较高

7. 静态内部类

静态内部类也是作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象

  • 在外部类加载时，静态内部类不会被立即加载，而是在外部类中被使用时才会加载，这符合懒加载的策略。
  • 当我们在外部类中调用静态内部类时，会被加载，并且只会被加载一次，在加载时线程是安全的，保障了线程的安全性。
 class StaticInner {

    private StaticInner() { }

    //静态内部类
    private static class Singleton {
        private static final StaticInner INSTANCE = new StaticInner();
    }

    public static StaticInner getSingleton() {
        return Singleton.INSTANCE;
    }

    public void print() {
        System.out.println("静态内部类的线程安全的懒汉式单例");
    }
}

public class StaticInnerSingle {
    public static void main(String[] args) {
        StaticInner single = StaticInner.getSingleton();
        single.print();
    }
}

静态内部类

  • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
  • 静态内部类方式在外部类被加载时并不会立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成外部类的实例化。
  • 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
  • 优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高

8. 枚举

这借助DK15中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

 enum Singleton {
    INSTANCE; //属性

    public static Singleton getInstance() {
        return Singleton.INSTANCE;
    }
}

public class Enum {
    public static void main(String[] args) {
        Singleton single = Singleton.getInstance();
        Singleton single = Singleton.getInstance();
        System.out.println(single == single);
    }
}

9. 反射！为所欲为？

DCL双重检查破坏

通过反射或者序列化会破坏单例，我们就以线程安全的DCL单例来说明。

还是tittle6的代码，我们通过反射来破坏

 public static void main(String[] args) throws Exception {
    SafeSingleton single = SafeSingleton.getInstance();
     Constructor <SafeSingleton> dc = SafeSingleton.class.getDeclaredConstructor();
    dc.setAccessible(true);
    SafeSingleton singleCopy = dc.newInstance();
    // false ,单例被破坏
    System.out.println(singleCopy == single);
} 
 结果输出：false

输出为false，说明单例模式创建了两个对象，被反射破坏了。那如何解决呢？

首先，反射是通过 无参构造 来创建class对象的，我们在SafeSingleton的构造中再加一把锁来判断：

 class SafeSingleton {

    //使用volatile关键字保其可见性
    private volatile static SafeSingleton single = null;

    private SafeSingleton() {
        synchronized (SafeSingleton.class) {
            if (single != null) {
                throw new RuntimeException("Don't destroy by reflection");
            }
        }
    }

    //同步代码块上锁
    public static SafeSingleton getInstance() {
        if(single == null) {
            synchronized (SafeSingleton.class) {
                //双重检查
                if (single == null) {
                    single = new SafeSingleton();
                }
            }
        }
        return single;
    }
}

public class ReflectDCL {
    public static void main(String[] args) throws Exception {
        SafeSingleton single = SafeSingleton.getInstance();
        Constructor<SafeSingleton> dc = SafeSingleton.class.getDeclaredConstructor();
        dc.setAccessible(true);
        SafeSingleton singleCopy = dc.newInstance();
        //false,单例被破坏
        System.out.println(singleCopy == single);
    }
}

问题解决，此时反射无法创建对象。

问题又双出现

刚才单例的对象是通过私有构造方法创建的，即调用了getInstance()方法。但是，我不用这样创建，我唯一一个对象也是通过反射来创建呢？

将

 SafeSingleton single = SafeSingleton.getInstance();

换成

 SafeSingleton single = dc.newInstance();

这时，单例模式又出幺蛾子了，又被反射获取了！

问题解决

我们可以通过添加一个标志位 flag 来判断，防止反射破坏

 class SafeSingleton {

    //使用volatile关键字保其可见性
    private volatile static SafeSingleton single = null;
    //添加标志位
    private static boolean flag = false;

    private SafeSingleton() {
        synchronized (SafeSingleton.class) {
            if (flag == false) {
                flag = true;
            }else {
                throw new RuntimeException("Don't destroy by reflection");
            }
        }
    }

    //同步代码块上锁
    public static SafeSingleton getInstance() {
        if(single == null) {
            synchronized (SafeSingleton.class) {
                //双重检查
                if (single == null) {
                    single = new SafeSingleton();
                }
            }
        }
        return single;
    }

    public static void main(String[] args) throws Exception {
        Constructor<SafeSingleton> dc = SafeSingleton03.class.getDeclaredConstructor();
        dc.setAccessible(true);
        SafeSingleton single = dc.newInstance();
        SafeSingleton singleCopy = dc.newInstance();

        System.out.println(single);
        System.out.println(singleCopy);
        System.out.println(single == singleCopy);
    }
}

再次执行，我们发现标志位法可以拦截两次反射的破坏。

问题又双叒出现

在反射中，我们不仅可以获取构造方法呀，还可以获取成员变量呀。那flag通过反射获取并修改，不就有不行了？

 class SafeSingleton {

    //使用volatile关键字保其可见性
    private volatile static SafeSingleton single = null;
    //添加标志位
    private static boolean flag = false;

    private SafeSingleton() {
        synchronized (SafeSingleton.class) {
            if (flag == false) {
                flag = true;
            }else {
                throw new RuntimeException("Don't destroy by reflection");
            }
        }
    }

    //同步代码块上锁
    public static SafeSingleton getInstance() {
        if(single == null) {
            synchronized (SafeSingleton.class) {
                //双重检查
                if (single == null) {
                    single = new SafeSingleton();
                }
            }
        }
        return single;
    }

    public static void main(String[] args) throws Exception {
        Constructor<SafeSingleton> dc = SafeSingleton03.class.getDeclaredConstructor();
        dc.setAccessible(true);
        SafeSingleton single = dc.newInstance();

        //再次通过反射修改属性值
        Field flag = SafeSingleton.class.getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(dc,false);

        SafeSingleton singleCopy = dc.newInstance();

        System.out.println(single);
        System.out.println(singleCopy);
        System.out.println(single == singleCopy);
    }
}

通过代码验证，我们发现确实又双出现问题了！

那这，又该怎么搞？

问题，就出在了newInstance方法上，通过反射来创建对象。

我们点开源码看看

咦，枚举自带单例模式，反射还破坏不了。是这样吗？我们继续验证

问题最终解决

测试反射能否破坏枚举式单例 

 enum EnumSingleton {
    INSTANCE;
}

public class EnumTest {
    public static void main(String[] args) throws Exception {
        EnumSingleton single = EnumSingleton.INSTANCE;
        Constructor<EnumSingleton> dc = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
        dc.setAccessible(true);
        EnumSingleton singleCopy = dc.newInstance();

        System.out.println(single);
        System.out.println(singleCopy);
        System.out.println(single == singleCopy);
    }
}
至于为什么反射获取的构造方法传入String、int参数，需要通过Jad反编译来查看。不能传入空参构造，否则出现的是NoSuchMethodException

出现源码中抛出的异常IllegalArgumentException

程序最终抛出：java.lang.IllegalArgumentException: Cannot reflectively create enum objects异常

总结

在JDK中，java.lang.Runtime就是经典的单例模式

掌握这样一些单例模式的奇淫技巧，在历经反射的重重爆破之后，相信你会对单例模式有新的了解！

java面试之java IO
上一篇
Java–Socket编程TCP通信
下一篇