单例模式学习

最新推荐文章于 2024-07-25 13:59:31 发布

很大森

最新推荐文章于 2024-07-25 13:59:31 发布

阅读量268

点赞数

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

本文链接：https://blog.csdn.net/qq_43545600/article/details/127746486

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

单例模式

1.单例模式的应用场景
2.保证线程安全的单例模式策略
3.反射暴力攻击单例解决方案和原理
4.序列化破坏单例的原理和解决方案
5.注册式单例模式

单例模式的应用场景

单例模式（singleton pattern）是指一个类在任何情况下都绝对只有一个实例，并且提供一个全局访问点。单例模式是创建型模式，在J2EE中的ServletContext、Spring中的ApplicationContext、数据库连接池等都有应用。

单例模式可以保证内存中只有一个实例，减少内存的开销避免对资源的重复占用。

饿汉式单例模式

/**
 * 饿汉式单例模式在类的加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出现开始之前就初始化了，不存在访问安全问题。
 */
public class HungarySingleton {

    //先静态后动态
    //先属性后方法
    //先上后下
    private static final HungarySingleton hungarySingleton = new HungarySingleton();

    private HungarySingleton(){};

    public static HungarySingleton getInstance(){
        return hungarySingleton;
    }

}
public class HungaryStaticSingleton{
    /*
        ******************************************
        静态代码块写法
        ******************************************
     */
    private static final HungaryStaticSingleton hungaryStaticSingleton;

    static{
        hungaryStaticSingleton = new HungaryStaticSingleton();
    }
    public static HungaryStaticSingleton getInstance(){
        return hungaryStaticSingleton;
    }
}

饿汉式用于单例的情况比较少，虽然可以保证线程的绝对安全，执行效率也高，但是缺点也很明显，所有的对象类加载的时候就会实例化。这样就会造成系统中有大批量的单例对象存在，会造成内存浪费。

懒汉式单例模式

/**
 * 懒汉式是为了解决饿汉式单例可能带来的内存资源浪费，单例对象要在被使用的时候才会初始化
 */
public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    //公共内存区域
    private static LazySimpleSingleton lazy = null;
    public static LazySimpleSingleton getInstance(){
        if (lazy == null){
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }
    /**
     如果在多线程环境下，这种写法会带来线程安全问题。
     */
}


public class ExeThread implements Runnable{
    
    public void run() {
        LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+"==="+singleton);
    }


    public static void main(String[] args) {
        Thread t1 = new Thread(new ExeThread());
        Thread t2 = new Thread(new ExeThread());
        t1.start();
        t2.start();
    }

    /**
     下图说明上述的单例存在安全隐患，可以debug通过观测其内存状态，LazySimpleSingleton被实例化了两次
     ，偶然会得到两个相同的对象。实际上是被后面执行的线程覆盖了。
     */
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HyBr4gaq-1667875793900)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221031160126118.png)]$

懒汉式多线程环境下优化

在getInstance()方法加上 synchronized关键字，变成线程同步方法

public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    //公共内存区域
    private static LazySimpleSingleton lazy = null;
    public synchronized static LazySimpleSingleton getInstance(){
        if (lazy == null){
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }
    /**
     这个方法虽然解决了线程的安全问题，但是在线程数量比较多的情况下，CPU分配压力上升，会导致大批线程阻塞。
    */
}

执行其中一个线程并且调用getInstance方法时，另一个线程调用getInstance方法，线程状态由RUNNING到MONITOR，出现阻塞直到第二个线程才会恢复到RUNNING。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XrKyEhfX-1667875793901)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221031162420154.png)]$

双重检查锁单例模式

解决线程安全和性能问题

public class LazyDoubleCheckSingleton {

    private LazyDoubleCheckSingleton(){}
    private static LazyDoubleCheckSingleton lazy = null;
    public  static LazyDoubleCheckSingleton getInstance(){
        if (lazy == null){
            synchronized(LazyDoubleCheckSingleton.class){
                if (lazy == null){
                    lazy = new LazyDoubleCheckSingleton();
                    /*
                     1、分配内存
                     2、初始化对象
                     3、设置lazy指向刚分配的内存地址
                     */
                }
            }
        }
        return lazy;
    }
}
/**
    当第一个线程调用getInstance方法时，第二个线程也可以调用，但是执行到synchronized
    第二个线程会变成MONITOR状态出现阻塞。这时的阻塞不是基于整个单例类的阻塞而是getInstance
    方法内部的阻塞，只要逻辑不复杂，影响也是微乎其微的。
 */

由于synchronized的局限性，使用synchronized关键字，不上锁也会引发一系列问题。这时可以考虑静态内部类的方式

静态内部类方式单例模式

/**
 * 兼顾饿汉式单例内存浪费和synchronized性能问题
 */
public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton(){}

    //如果没有使用静态内部类是不加载的
    //static实现单例的空间共享，final保证不会重写和覆盖
    public static final LazyInnerClassSingleton getInstance(){

        //再返回结果之前，一定会加载内部类
        return LazyHolder.lazy;
    }

    private static class LazyHolder{
        private static final LazyInnerClassSingleton lazy = new LazyInnerClassSingleton();
    }

}

破解单例模式和解决

反射破坏单例模式

import java.lang.reflect.Constructor;

public class LazyInnerClassSingletonTest {
    public static void main(String[] args) {
        try {
            Class<?> clazz = LazyInnerClassSingleton.class;

            //通过反射获取私有的构造方法
            Constructor c = clazz.getDeclaredConstructor(null);

            //强制访问
            c.setAccessible(true);

            //暴力初始化
            Object o1 = c.newInstance();

            //调用两次构造方法
            Object o2 = c.newInstance();

            System.out.println(o1 == o2);//输出：false

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//解决方案 当出现重复创建时，抛出异常
public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton(){
        if (LazyHolder.lazy != null){
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    //如果没有使用静态内部类是不加载的
    //static实现单例的空间共享，final保证不会重写和覆盖
    public static final LazyInnerClassSingleton getInstance(){

        //再返回结果之前，一定会加载内部类
        return LazyHolder.lazy;
    }

    private static class LazyHolder{
        private static final LazyInnerClassSingleton lazy = new LazyInnerClassSingleton();
    }

}

序列化破坏单例

/**
 一个单例对象创建好之后，有时候需要将对象序列化，然后写入磁盘，
 下次使用时再从磁盘中读取对象并且进行反序列化将其转化为单例对象
 */
public class SerializeSingleton implements Serializable {

    /**
     序列化：将内存中的状态通过转换成字节码的形式，从而转换成I/O流。写入其他地方，内存中的状态永久保存下来

     反序列化：将已经持久化的字节码内容转换为I/O流，通过流的读取，进而将读取的内容转换为java对象，转换过程中会重新创建对象

     */

    public final static SerializeSingleton INSTANCE = new SerializeSingleton();

    private SerializeSingleton(){}

    public static SerializeSingleton getInstance(){
        return INSTANCE;
    }
}



public class SerializeSingletonTest {
    public static void main(String[] args) {
        SerializeSingleton s1 = null;
        SerializeSingleton s2 = SerializeSingleton.getInstance();

        FileOutputStream fos = null;

        try {
            fos = new FileOutputStream("SerializeSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SerializeSingleton.obj");
            ObjectInputStream  ois = new ObjectInputStream(fis);
            s1 = (SerializeSingleton) ois.readObject();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

            /**
             输出结果：
             com.demo.danli.SerializeSingleton@58372a00
             com.demo.danli.SerializeSingleton@135fbaa4
             false
             反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例的原则
             */
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//解决方法 添加readResolve方法
public class SerializeSingleton implements Serializable {

    public final static SerializeSingleton INSTANCE = new SerializeSingleton();

    private SerializeSingleton(){}

    public static SerializeSingleton getInstance(){
        return INSTANCE;
    }

    private Object readResolve(){
        return INSTANCE;
    }

}
/**
增加read方法虽然解决了单例模式在序列化中的问题，但是实际还是实例化了两次，创建的新对象没有返回而已
如果创建对象的动作频率加快，就意味着内存分配开销也会加大。
*/

注册式单例模式

注册式单例模式又称为登记式单例模式：将每一个示例都登记到某个地方，使用唯一的标识获取实例。

注册式单例模式有两种:一种是枚举式单例模式，另一种为容器式单例模式。

枚举式单例模式

/**
 * 枚举式单例，在类加载时就会将所有的对象初始化放在内存中，原理和饿汉式类似，不适合大量创建对象的场景
 */
public enum EnumSingleton {

    INSTANCE;
    private Object data;


    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

public class EnumSingletonTest {

    public static void main(String[] args) throws Exception {
        EnumSingleton instance1 = null;
        EnumSingleton instance2 = EnumSingleton.getInstance();
        FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance2);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream("EnumSingleton.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);
        instance1 = (EnumSingleton) ois.readObject();
        ois.close();

        System.out.println(instance1.getData());
        System.out.println(instance2.getData());
        System.out.println(instance1.getData()==instance1.getData());


    }
}

容器式单例模式

/**
 * 容器式单例适合创建大量单例对象的场景，便于管理，缺点是线程不安全的。
 */
public class ContainerSingleton {

    private ContainerSingleton(){}
    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();
    public static Object getBean(String className){
        synchronized (ioc){
            if(!ioc.containsKey(className)){
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className,obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            }else {
                return ioc.get(className);
            }
        }
    }

}

ThreadLocal(单例实现)

/**
 * ThreadLocal 不能保证创建的对象是全局唯一的，但是保证了在单个线程是唯一的。
 */
public class ThreadLocalSingleton {

    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue(){
                    return new ThreadLocalSingleton();
                }
            };
    private ThreadLocalSingleton(){}
    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }

    public static void main(String[] args) {
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());

        Thread t1 = new Thread(new ExeThread());
        Thread t2 = new Thread(new ExeThread());
        t1.start();
        t2.start();
    }

}

/**
主线程调用多次，获取到的实例都是同一个
单例模式为了达到线程安全给方法上锁，以时间换取空间。
ThreadLocaL将所有的对象全部放在TheadLocalMap中，为每个线程提供对象，以空间换取时间
com.demo.danli.ThreadLocalSingleton@1540e19d
com.demo.danli.ThreadLocalSingleton@1540e19d
com.demo.danli.ThreadLocalSingleton@1540e19d
com.demo.danli.ThreadLocalSingleton@1540e19d
com.demo.danli.ThreadLocalSingleton@1540e19d
com.demo.danli.ThreadLocalSingleton@1540e19d
Thread-1===com.demo.danli.LazySimpleSingleton@5c570a66
Thread-0===com.demo.danli.LazySimpleSingleton@5c570a66
*/