浅谈设计模式 - 单例模式(一)

什么是单例模式?

浅谈设计模式 - 单例模式(一)_第1张图片

介绍

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

单例模式的几个应用场景

  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》的解释

浅谈设计模式 - 单例模式(一)_第2张图片

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

浅谈设计模式 - 单例模式(一)_第3张图片

扩展:序列化必知:

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

来源:

我不会去拾人牙慧,所以这里记录一下

java序列化,看这篇就够了

其他优质文章:

Java实现单例的5种方式

你可能感兴趣的