浅谈设计模式 - 单例模式（一）

什么是单例模式？

介绍

保证一个类仅有一个实例，并提供一个全局访问点

单例模式的几个应用场景

1. SpringBean 默认就是单例的，不过用的是动态代理生成代理对象
2. 工具类里面，由一个单例保存
3. 其他需要唯一对象的场景

如何实现单例模式

饿汉式

解释：和名字一般，很饿，所以在使用之前就做好了准备

优点：

1. 保证单例对象不会重复
2. 永远不会有重复创建的隐患

缺点：

1. 如果对象较大比较占用jvm内存空间
2. 影响性能，带来没有必要的对象创建。

实现代码：

/**
 *
 * 单例模式 - 饿汉式
 * @author zhaoxudong
 * @version 1.0
 * @date 2020/10/27 21:45
 */
public class Hungry {

    private static final Hungry instance = new Hungry();

    public static Hungry getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        Hungry instance = Hungry.getInstance();
        System.err.println(instance);
    }
}

非常简单，在创建之前，旧对对象进行了初始化，其实对于比较小的对象，这种方式在实际的使用过程中最多

懒汉式

解释：犹如一个懒汉，只有在使用到的时候，才进行初始化。

优点：

1. 可以节省系统资源只有真正使用的时候，才会进行获取
2. 对于

缺点：

1. 如果多线程并发访问会出现多次实例化的问题

实现代码：

package com.zxd.interview.desginpattern.single;

import com.zxd.interview.util.ExecuteUtil;

/**
 * 单例模式 - 懒汉式
 *
 * @author zhaoxudong
 * @version 1.0
 * @date 2020/10/27 21:45
 */
public class Lazy {

    public static void main(String[] args) {
        // 常规多线程
//        for (int i = 0; i < 100; i++) {
//            new TestRunThread().start();
//        }
        try {
            ExecuteUtil.startTaskAllInOnce(50000, new TestRunThread());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 模拟异步请求
 * 模拟十组数据
 */
class TestRunThread extends Thread {

    @Override
    public void run() {
        // 懒汉式第一版
//        int i = LazyVersion1.getInstance().hashCode();
        // 懒汉式第二版
//        int i = LazyVersion2.getInstance1().hashCode();
        // 懒汉式第三版
        int i = LazyVersion2.getInstance2().hashCode();
        System.err.println(i);
    }
}

/**
 * 饿汉式的第一版本
 */
class LazyVersion1 {

    private static LazyVersion1 lazyVersion1;

    public static LazyVersion1 getInstance() {
        if (lazyVersion1 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lazyVersion1 = new LazyVersion1();
        }
        return lazyVersion1;
    }


}

/**
 * 懒汉式的第二版本
 * 1. 直接对整个方法加锁
 * 2. 在局部代码块加锁
 */
class LazyVersion2 {

    /**
        非常重要的点： volatile 避免cpu指令重排序
    */
    private static volatile LazyVersion2 lazyVersion2;

    /**
     * 在方法的整体加入 synchronized
     *
     * @return
     */
    public synchronized static LazyVersion2 getInstance1() {
        if (lazyVersion2 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lazyVersion2 = new LazyVersion2();
        }
        return lazyVersion2;
    }

    /**
     * 在局部代码快加入 synchronized
     *
     * @return
     */
    public static LazyVersion2 getInstance2() {
        if (lazyVersion2 == null) {
            // 验证是否创建多个对象
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (LazyVersion2.class) {
                if (lazyVersion2 == null) {
                    lazyVersion2 = new LazyVersion2();
                }
            }
        }
        return lazyVersion2;
    }


}

注意点：

1. ​​volatile​​ 关键字是JDK1.5之后的JMM为了防止CPU指令重排序的问题而加入的一种具体机制
2. 虽然发生的几率非常小的，但是指令重排序是JVM的本身特点

private static volatile LazyVersion2 lazyVersion2;

静态代码块

和饿汉式差不多，这里不在过多赘述，直接上代码：

实现代码：

/**
 * 静态代码块的形式，实现单例
 *
 * @Author zhaoxudong
 * @Date 2020/10/28 13:28
 **/
public class StaticBlock {

    private static final StaticBlock staticBlock;

    static {
        staticBlock = new StaticBlock();
    }

    public static StaticBlock getInstance() {
        return staticBlock;
    }
}

静态内部类：

优点：

1. 既可以保证一次加载，又可以保证不出现重复的初始化
2. 可以用一个大类管理所有的内部类

缺点：

1. 额外需要多一个内部类
2. 破坏代码设计模式

实现代码：

package com.zxd.interview.desginpattern.single;

import com.zxd.interview.util.ExecuteUtil;

/**
 * 单例模式 - 静态内部类实现
 *
 * @Author zhaoxudong
 * @Date 2020/10/28 13:35
 **/
public class SingleStaticInner {

    /**
     * 使用内部类来进行后续的构造
     */
    public static class Instatnce {
        private static Instatnce instatnce = new Instatnce();

        public static Instatnce getInstatnce() {
            try {
                // 模拟在创建对象之前做一些准备工作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return instatnce;
        }

    }

    public static void main(String[] args) throws InterruptedException {
        ExecuteUtil.startTaskAllInOnce(250, new ThreadTest());
    }
}

/**
 * 测试多线程获取对象
 */
class ThreadTest extends Thread {

    @Override
    public void run() {
        System.err.println(SingleStaticInner.Instatnce.getInstatnce());

    }
}

序列化/反序列化的问题：

解释：序列化和反序列化的情况下，会出现问题，因为JAVA的序列化从磁盘读取的时候，会生成新的实例对象，但是这样就会违背单例模式的方式

实现代码：

package com.zxd.interview.desginpattern.single;

import java.io.*;

/**
 * 单例模式 - 序列化与反序列化的问题和解决办法
 * @Author zhaoxudong
 * @Date 2020/10/28 13:55
 **/
public class SingleSerialize {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        SerializeStaticInner instance = SerializeStaticInner.getInstance();

        System.err.println(instance.hashCode());

        // 序列化
        FileOutputStream fileOutputStream = new FileOutputStream("temp");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        objectOutputStream.writeObject(instance);
        objectOutputStream.close();
        fileOutputStream.close();

        // 反序列化
        FileInputStream fileInputStream = new FileInputStream("temp");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        SerializeStaticInner read = (SerializeStaticInner) objectInputStream.readObject();
        objectInputStream.close();
        fileInputStream.close();
        System.err.println(read.hashCode());


    }

    static class SerializeStaticInner implements Serializable{

        private static  SerializeStaticInner serializeStaticInner = new SerializeStaticInner();

        public static SerializeStaticInner getInstance(){
            return serializeStaticInner;
        }

        /**
         * 序列化当中的一个钩子方法
         * 避免序列化和反序列化的对象为新实例破坏单例模式的规则
         */
//        protected Object readResolve(){
//            System.err.println("调用特定的序列化方法");
//            return SerializeStaticInner.serializeStaticInner;
//        }
    }

}

1. 如果没有​​readResolve()​​，那么序列化之后反序列化是会变为一个新的实例，这样会破坏单例模式
2. 如果存在​​readResolve()​​，那么序列化之后的对象就不会出现多个实例

扩展：为什么加入​​readResolve()​​ 方法就可以避免序列化的问题

下面是关于《effective Java》的解释

关于此方法的访问权注意事项

扩展：序列化必知：

• 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
• 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
• 如果想让某个变量不被序列化，使用transient修饰。
• 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
• 反序列化时必须有序列化对象的class文件。
• 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
• 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
• 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
• 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。