设计模式之单例模式

最新推荐文章于 2023-06-15 17:22:31 发布

皓晨的架构笔记

最新推荐文章于 2023-06-15 17:22:31 发布

阅读量97

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/chen_changying/article/details/89424995

版权

设计模式专栏收录该内容

18 篇文章 0 订阅

订阅专栏

什么是单例模式

单例模式，是一种常用的软件设计模式。是指在应用整个生命周期内只能存在一个实例。避免实例的重复创建，即一个类只有一个对象实例，从而减少开销，节省内存。

构建的几种方式：

懒汉式：当用到的时候才会创建实例（线程安全、效率低，可延迟加载）
饿汉式：当类加载的时候就会创建实例（线程安全、效率高，不可延迟加载）；

两种构建方式区别

懒汉式：在需要的时候才会创建对象,多线程环境下，会产生线程安全问题安全，为了保证线程安全，加上同步代码块后，代码效率会比饿汉式低

饿汉式：当class文件被加载的时候就初始化，不会产生线程安全问题，但不管此类有没有被使用，都会占用一定的内存资源

通常使用后者饿汉式

常见的应用场景

项目读取配置文件的类，一般之后一个对象，不需要每次使用配置文件数据的时候都new一个对象；
程序的日志记录；
数据库连接池；
Spring 容器里的bean，默认也是单例的；
基于servlet开发，servlet也是单例的；

实现的方式有很多种，下面我将一一介绍

单例模式-懒汉式实现方式

1.实现方式一-懒汉式(线程安全、效率低、可延迟加载)

public class SingletionOfSlacker1 {

    private static SingletionOfSlacker1 singletionOfSlacker;

    // 构造方法私有化
    private SingletionOfSlacker1() {

    }

    public static SingletionOfSlacker1 getInstance() {
        if (null == singletionOfSlacker) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            singletionOfSlacker = new SingletionOfSlacker1();
        }
        return singletionOfSlacker;
    }
}

模拟10个线程同时调用来测试一下：

public class SingletionTest {

    public static void main(String[] args) {
        
        int threadNum = 10;
        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(SingletionOfSlacker1.getInstance());
                }
            }).start();
        }
    }
}

输入结果如下：

com.chaytech.example.singleton.SingletionOfSlacker1@7191d02f
com.chaytech.example.singleton.SingletionOfSlacker1@368f0890
com.chaytech.example.singleton.SingletionOfSlacker1@11f3ef5e
com.chaytech.example.singleton.SingletionOfSlacker1@1fe9b76c
com.chaytech.example.singleton.SingletionOfSlacker1@4336eeed
com.chaytech.example.singleton.SingletionOfSlacker1@5a6b83b0
com.chaytech.example.singleton.SingletionOfSlacker1@3a89f671
com.chaytech.example.singleton.SingletionOfSlacker1@37ce62b5
com.chaytech.example.singleton.SingletionOfSlacker1@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker1@4178d239

可以看到打印的内存地址值是不一致的，说明在多线程环境下，产生了多个对象，这种实现方式是线程不安全的，也就不符合单例模式的要求了。

那怎样可以保证线程是安全的呢？在Java语言中，可以使用synchronized关键字修饰方法或者代码块，保证线程安全。

下面我们在方法上加上synchronized关键字试一下：

public class SingletionOfSlacker2 {

    private static SingletionOfSlacker2 singletionOfSlacker;

    // 构造方法私有化
    private SingletionOfSlacker2() {

    }

    public static synchronized SingletionOfSlacker2 getInstance() {
        if (null == singletionOfSlacker) {
            singletionOfSlacker = new SingletionOfSlacker2();
        }
        return singletionOfSlacker;
    }
}

输出结果如下：

com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0
com.chaytech.example.singleton.SingletionOfSlacker2@421674f0

可以看到打印的内存地址值是一致的，但是因为方法上加了synchronized关键字，当下个线程在调用这个方法的时候需要先拿到锁，如果拿不到，就需要等待上一个线程释放锁，才可继续执行，这样也就带来了效率低的问题。

当然我们也可以不对方法加锁，可以直接对代码块加锁，这样也能实现线程安全，但效率也低：

public class SingletionOfSlacker3 {

    private static SingletionOfSlacker3 singletionOfSlacker;

    // 构造方法私有化
    private SingletionOfSlacker3() {

    }

    public static SingletionOfSlacker3 getInstance() {
        synchronized (SingletionOfSlacker3.class) {
            if (null == singletionOfSlacker) {
                singletionOfSlacker = new SingletionOfSlacker3();
            }
        }
        return singletionOfSlacker;
    }
}

接着我们来思考一样，如果只对创建对象这段代码加同步锁，结果会不会是一样呢？下面我们来验证一下：

public class SingletionOfSlacker4 {

    private static SingletionOfSlacker4 singletionOfSlacker;

    // 构造方法私有化
    private SingletionOfSlacker4() {

    }

    public static SingletionOfSlacker4 getInstance() {
        if (null == singletionOfSlacker) {
            synchronized (SingletionOfSlacker4.class) {
                singletionOfSlacker = new SingletionOfSlacker4();
            }
        }
        return singletionOfSlacker;
    }
}

输出结果如下：

com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@4336eeed
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@3a89f671
com.chaytech.example.singleton.SingletionOfSlacker4@48e0ce1c
com.chaytech.example.singleton.SingletionOfSlacker4@3a89f671

从上面的结果可以看出这样是线程不安全的，为什么会这样呢？假设有两个线程，分别是线程1和线程2，当这两个线程同时走到了判断对象是否为空的这段代码处，此时对象还没有创建所以是空的，因此都能走到条件判断里面去，此时线程1先拿到了锁，创建了对象，释放锁之后，线程2也拿到了，也创建了对象，因此就创建了多个对象，产生了线程安全问题。

看到这里，有些同学可能想说，在同步代码块里再加个null判断不就行了，是的，这样是可以的，这种方式我们称为双重检查锁,只有初次调用时才会进入到同步代码块里，很好的解决了效率与线程安全问题。

如下所示：

public class SingletionOfSlacker4 {

    private static SingletionOfSlacker4 singletionOfSlacker;

    // 构造方法私有化
    private SingletionOfSlacker4() {

    }

    public static SingletionOfSlacker4 getInstance() {
        if (null == singletionOfSlacker) {
            synchronized (SingletionOfSlacker4.class) {
                if(null == singletionOfSlacker) {
                    singletionOfSlacker = new SingletionOfSlacker4();
                }
            }
        }
        return singletionOfSlacker;
    }
}

PS：由于由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用这种方法。

2.实现方式二-静态内部类(线程安全、效率高、可延迟加载)

public class SingletionOfSlacker5 {

    public static class SingletionOfSlackerInstance {
        private static SingletionOfSlacker5 INSTANCE = new SingletionOfSlacker5();
    }

    // 构造方法私有化
    private SingletionOfSlacker5() {

    }

    public static SingletionOfSlacker5 getInstance() {
        return SingletionOfSlackerInstance.INSTANCE;
    }
}

输出结果如下：

com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239
com.chaytech.example.singleton.SingletionOfSlacker5@4178d239

此方式只有真正调用getInstance()方法时,才会加载静态内部类。加载类时是线程安全的。 INSTANCE是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性，并兼备了并发高效调用和延迟加载的优势；

单例模式-饿汉式实现方式

1.实现方式一-饿汉式(线程安全、效率高、不可延迟加载)

public class SingletionOfHungry1 {

    // 当class文件加载时初始化
    private static SingletionOfHungry1 singletionOfHungry = new SingletionOfHungry1();

    // 构造方法私有化
    private SingletionOfHungry1(){

    }

    public static SingletionOfHungry1 getInstance(){
        return singletionOfHungry;
    }
}

2.实现方式二-使用枚举(线程安全、效率高、不可延迟加载)

public enum SingletionOfHungry2 {
    // 定义一个枚举元素，代表SingletionOfHungry2的实例
    INSTANCE;

    /**
     * 枚举也可以定义具体操作
     */
    public void operation(){

    }
}

输出结果如下，对象的hashcode：

此种方式实现简单，枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！

上面所介绍的几种单例模式的实现方式，都能保证线程是安全的，但是，我们都知道Java通过反射和反序列化也是可以生成多个对象的，因此上面的几种实现方式除了枚举外，都存在反射和反序列化漏洞，下面我将讲解这个，如何来避免出现这种问题。

单例模式-防范反射和反序列化的漏洞

先演示一个不做防范的结果：

public class SingletionTest {

    public static void main(String[] args) throws Exception {
        // 通过反射调用私有构造方法
        Class<SingletionOfHungry1> clazz = (Class<SingletionOfHungry1>)Class.forName("com.chaytech.example.singleton.SingletionOfHungry1");
        Constructor<SingletionOfHungry1> constructor = clazz.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        SingletionOfHungry1 s1 = constructor.newInstance();
        SingletionOfHungry1 s2 = constructor.newInstance();
        System.out.println(s1);
        System.out.println(s2);
    }
}

输出结果如下：

com.chaytech.example.singleton.SingletionOfHungry1@4554617c
com.chaytech.example.singleton.SingletionOfHungry1@74a14482

下面再来看看反序列化：

public class SingletionOfHungry1 implements Serializable{

    // 当class文件加载时初始化
    private static SingletionOfHungry1 singletionOfHungry = new SingletionOfHungry1();

    // 构造方法私有化
    private SingletionOfHungry1(){

    }

    public static SingletionOfHungry1 getInstance(){
        return singletionOfHungry;
    }
}

public class SingletionTest {

    public static void main(String[] args) throws Exception {
        SingletionOfHungry1 s1 = SingletionOfHungry1.getInstance();
        FileOutputStream outputStream = new FileOutputStream("E:/test.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(s1);
        objectOutputStream.close();
        outputStream.close();
        System.out.println(s1);

        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("E:/test.txt"));
        SingletionOfHungry1 obj1 = (SingletionOfHungry1) inputStream.readObject();
        System.out.println(obj1);
    }
}

输出结果如下：

com.chaytech.example.singleton.SingletionOfHungry1@7f31245a
com.chaytech.example.singleton.SingletionOfHungry1@6d6f6e28

可以看到分别都生成了新的对象。
怎么来防范呢？反射的话，可以在构造方法中手动抛出异常控制，反序列化可以通过定义readResolve()方法防止获得不同对象。反序列化时，如果对象所在类定义了readResolve()方法,则会自动调用这个 readResolve()方法来返回我们指定好的对象了;

下面来看具体的代码示例：

public class SingletionOfHungry1 implements Serializable{

    // 当class文件加载时初始化
    private static SingletionOfHungry1 singletionOfHungry = new SingletionOfHungry1();

    // 构造方法私有化
    private SingletionOfHungry1(){
        if(null != singletionOfHungry){
            throw new RuntimeException("此类只能创建一个对象");
        }
    }

    public static SingletionOfHungry1 getInstance(){
        return singletionOfHungry;
    }
    
	// 反序列化时，如果对象所在类定义了readResolve()则会自动调用这个 `readResolve()`方法来返回我们指定好的对象了
    private Object readResolve() throws ObjectStreamException {
        return singletionOfHungry;
    }
}

通过反射多次获取时：

Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.chaytech.example.singleton.SingletionTest.main(SingletionTest.java:29)
Caused by: java.lang.RuntimeException: 此类只能创建一个对象
	at com.chaytech.example.singleton.SingletionOfHungry1.<init>(SingletionOfHungry1.java:25)
	... 5 more

反序列时输出结果：

com.chaytech.example.singleton.SingletionOfHungry1@7f31245a
com.chaytech.example.singleton.SingletionOfHungry1@7f31245a

ok，最后总结一下，如何选用：

当不考虑资源占用时，不需要延时加载：枚举要好饿汉式；
当考虑资源占用时，需要延时加载：静态内部类要好于懒汉式；

皓晨的架构笔记

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之单例模式

什么是单例模式单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。有两种构建方式：懒汉方式：指全局的单例实例在第一次被使用时构建；饿汉方式：指全局的单例实例在类装载时构建；单例模式-饿汉式代码示例public class SingletionOfHungry {...
复制链接

扫一扫