单例模式学习笔记

最新推荐文章于 2024-05-07 11:35:56 发布



最新推荐文章于 2024-05-07 11:35:56 发布

阅读量289

点赞数 1

分类专栏：笔记 Java 文章标签：单例模式 java 开发语言

本文链接：https://blog.csdn.net/weixin_53849724/article/details/122813991

版权

笔记同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

Java

5 篇文章 0 订阅

订阅专栏

单例模式

饿汉式单例模式：

package com.zyc.playSingle;


//饿汉式单例模式
public class hungryMan {
    //私有构造器，这样就不能通过构造器创建实例了
    private hungryMan(){

    }

    private static final hungryMan HUNGR_MAN = new hungryMan();

    //只要有就给：饿汉的特点，使用static这样可以直接用类访问
    public static hungryMan getHungrMan(){
        return HUNGR_MAN;
    }
}

class t1{
    public static void main(String[] args) {
        hungryMan hungrMan = com.zyc.playSingle.hungryMan.getHungrMan();
        hungryMan hungrMan1 = hungryMan.getHungrMan();
        hungryMan hungrMan2 = hungryMan.getHungrMan();

        System.out.println(hungrMan);
        System.out.println(hungrMan1);
        System.out.println(hungrMan2);
    }
}

懒汉式单例模式：

package com.zyc.playSingle;


//懒汉式单例模式
public class lazyMan {

    private lazyMan(){

    }

    private  static lazyMan LAZY_MAN ;


    public static lazyMan getLAZY_MAN(){
        if (LAZY_MAN==null){
            LAZY_MAN= new lazyMan();
            return LAZY_MAN;
        }
        return LAZY_MAN;
    }

}
class t2{
    public static void main(String[] args) {
        lazyMan lazy_man = lazyMan.getLAZY_MAN();
        lazyMan lazy_man1 = lazyMan.getLAZY_MAN();
        System.out.println(lazy_man);
        System.out.println(lazy_man1);
    }
}

单线程情况下我们使用单例模式是安全的，那么多线程呢？

package com.zyc.playSingle;

public class DCLLazyMan {

    private  DCLLazyMan(){
      System.out.println(Thread.currentThread().getName()+"ing...."); //测试 每次打印创建单例的线程名
    }

    private static DCLLazyMan dclLazyMan;
	//懒汉模式
    public static DCLLazyMan getDclLazyMan(){
        if(dclLazyMan==null){
            dclLazyMan = new DCLLazyMan();
        }
        return dclLazyMan;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{

                DCLLazyMan.getDclLazyMan();

            }).start();
        }
    }
}

这里我们使用10个线程创建单例，结果如下：

我们看到结果不同，所以多线程情况下这个是线程不安全的

解决办法：加锁

//双重检测锁模式 DCL懒汉式
    public static DCLLazyMan getDclLazyMan(){
        if (dclLazyMan==null){
            synchronized (DCLLazyMan.class){
                if(dclLazyMan==null){
                    dclLazyMan = new DCLLazyMan();
                }
            }
        }

        return dclLazyMan;
    }

使用双重检测锁我们看到结果如下：

结果现在满足了我们的需求，那么已经完全保证线程问题了吗？

指令重排

原因：创建对象dclLazyMan = new DCLLazyMan();这行代码不是一个原子性操作，可能会造成指令重排（1.分配内存空间2.初始化对象3.对象指向内存空间//这三步的顺序会重新排序，有可能先进行3操作在进行2）

所以我们需要使用volatile避免指令重排

更改后代码如下：

package com.zyc.playSingle;

public class DCLLazyMan {

    private  DCLLazyMan(){
        System.out.println(Thread.currentThread().getName()+"ing....");
    }

    private volatile static DCLLazyMan dclLazyMan;

    //双重检测锁模式 DCL懒汉式
    public static DCLLazyMan getDclLazyMan(){
        if (dclLazyMan==null){
            synchronized (DCLLazyMan.class){
                if(dclLazyMan==null){
                    dclLazyMan = new DCLLazyMan();
                }
            }
        }

        return dclLazyMan;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{

                DCLLazyMan.getDclLazyMan();

            }).start();
        }
    }
}

使用反射破解单例模式

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        DCLLazyMan dclLazyMan1 = DCLLazyMan.getDclLazyMan();
        Constructor<DCLLazyMan> declaredConstructor = DCLLazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        DCLLazyMan dclLazyMan = declaredConstructor.newInstance();
        System.out.println(dclLazyMan);
        System.out.println(dclLazyMan1);
    }

使用反射后可以发现创建两个对象不同；

解决办法，构造器进行判断

private static boolean flag  = false;

    private  DCLLazyMan(){
        synchronized (DCLLazyMan.class){
            if (flag==false){
                flag=true;
            }
            else{
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }

        System.out.println(Thread.currentThread().getName()+"ing....");
    }

但是我们上面是用反射创建了一个对象和原本创建的对象进行比较，如果全部使用反射创建对象呢？

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Constructor<DCLLazyMan> declaredConstructor = DCLLazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        DCLLazyMan dclLazyMan = declaredConstructor.newInstance();
        DCLLazyMan dclLazyMan1 = declaredConstructor.newInstance();
        System.out.println(dclLazyMan);
        System.out.println(dclLazyMan1);
    }

解决办法：使用标识符

private static boolean flag  = false;

    private  DCLLazyMan(){
        synchronized (DCLLazyMan.class){
            if (flag==false){
                flag=true;
            }
            else{
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }

        System.out.println(Thread.currentThread().getName()+"ing....");
    }

但是如果通过反编译或者其他手段获得我们设置的标识符呢？

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {

        Field flag = DCLLazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<DCLLazyMan> declaredConstructor = DCLLazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        DCLLazyMan dclLazyMan = declaredConstructor.newInstance();

        flag.set(dclLazyMan,false);
        DCLLazyMan dclLazyMan1 = declaredConstructor.newInstance();
        System.out.println(dclLazyMan);
        System.out.println(dclLazyMan1);
    }

通过修改标识符我们单例模式又被破坏了

解决办法：通过源码分析使用枚举

我们下面使用枚举类型进行分析

创建枚举类然后利用反射创建对象：

package com.zyc.playSingle;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

    //enum 是什么？ enum本身就是一个Class 类
    public enum enumSingle {
        INSTANCE;
        public enumSingle getInstance(){
            return INSTANCE;
        }
    }

    class Test{
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            enumSingle instance1 = enumSingle.INSTANCE;
            Constructor<enumSingle> declaredConstructor = enumSingle.class.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            enumSingle instance2 = declaredConstructor.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

报错如下：

我们发现结果跟源码中读的不同：

经过JAD工具进行反编译我们可以得到这里不是一个空参构造器，而是一个有参构造器

Constructor<enumSingle> declaredConstructor = enumSingle.class.getDeclaredConstructor(String.class,int.class);

修改后：

抛出异常正确，成功使用枚举类避免了反射的破坏



关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
单例模式学习笔记

单例模式饿汉式单例模式：package com.zyc.playSingle;//饿汉式单例模式public class hungryMan { //私有构造器，这样就不能通过构造器创建实例了 private hungryMan(){ } private static final hungryMan HUNGR_MAN = new hungryMan(); //只要有就给：饿汉的特点，使用static这样可以直接用类访问 public sta
复制链接

扫一扫