单例模式的五种写法

最新推荐文章于 2021-01-24 23:55:37 发布
最新推荐文章于 2021-01-24 23:55:37 发布
阅读量175 收藏
点赞数
分类专栏： 多线程基础 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ptGrapes/article/details/109206081
版权

一、饿汉式单例

饿汉式单例模式，实例对象在初始化的时候创建，不管有没有得到调用。好处是没有线程安全的问题，坏处是浪费内存空间。

//饿汉式单例
public class ehan {

    /**
     * 存在的问题：
     * 饿汉式强调的是一上来就初始化对象，初始化的对象里面又有很多像如下定义的很多数组同时也被初始化，
     * 但没有得到调用，就会存在浪费空间的情况
     * */
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];


    //构造器私有，保证别的方法无法调用生成这个对象
    private ehan(){}

    //实例对象初始化时创建
    private static final ehan HUNGRY = new ehan();

    public static ehan getInstance(){
        return HUNGRY;
    }

    public static void main(String[] args) {
        ehan ehan1 = ehan.getInstance();
        ehan ehan2 = ehan.getInstance();
        System.out.println(ehan1==ehan2);//true
    }

}

二、懒汉式

我们知道饿汉式在初始化的时候就完成了对象的创建，但存在浪费空间的问题，因此，懒汉式单例模式应运而生。
懒汉式顾名思义就是只有当需要的时候才会去初始化数据。

//懒汉式单例模式
public class lanhan {
    //构造器私有
    private lanhan(){
    }

    private static lanhan lazyMan;

    public static lanhan getInstance(){
        if(lazyMan==null){
            lazyMan = new lanhan();
        }
        return lazyMan;
    }

    public static void main(String[] args) {

        lanhan instance1 = lanhan.getInstance();
        lanhan instance2 = lanhan.getInstance();
        System.out.println(instance1==instance2);
    }


}

三、DCL（Double Check Lock）懒汉式

由于上述的懒汉式在单线程里确实是安全的，但是在多线程中，其实是并不安全的，我们可以通过以下代码测试：
我们会发现，得出的结果并不是单例的。

//懒汉式单例模式
public class lanhan {
    //构造器私有
    private lanhan(){
        System.out.println(Thread.currentThread().getName()+"OK");
    }

    private static lanhan lazyMan;

    public static lanhan getInstance(){
        if(lazyMan==null){
            lazyMan = new lanhan();
        }
        return lazyMan;
    }

    /**
     * 单线程下确实单例安全，但是多线程下是存在安全问题的
     *  我们得加锁
     * */
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lanhan.getInstance();
            }).start();
        }

        TimeUnit.SECONDS.sleep(3);

        lanhan instance1 = lanhan.getInstance();
        lanhan instance2 = lanhan.getInstance();
        System.out.println(instance1==instance2);

    }

}

因此我们得给他上锁，保证一个线程只能创建一个对象，也有且只能有一个对象。同时为了防止指令重排现象出现，我们得对变量加volatile锁。

//DCL懒汉式单例模式
public class lanhan {
    //构造器私有
    private lanhan(){
        System.out.println(Thread.currentThread().getName()+"OK");
    }
	//防止指令重排
    private static volatile lanhan lazyMan;

    //双重检测锁模式--DCL懒汉式检测
    public static lanhan getInstance(){
        //先判断有没有对象实例被创建，没有的话就锁住这个类，确保只有一个Class对象
        if(lazyMan==null){
            synchronized (lanhan.class){
                if(lazyMan==null){
                    //但是还可能存在一个问题，因为new lanhan()不是一个原子操作
                    /*
                     * 1.分配内存
                     * 2.执行构造方法
                     * 3.指向地址
                     * 有可能存在的问题就是由于指令重排，它的执行顺序完全有可能是132，这个时候由于指向了内存地址，
                     * 会被以为创建了对象，导致无法创建对象，为了保证不发生指令重排现象，我们必须加上volatile关键字
                     * */
                    lazyMan = new lanhan();
                }
            }
        }
        return lazyMan;
    }
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lanhan.getInstance();
            }).start();
        }

        TimeUnit.SECONDS.sleep(3);

        lanhan instance1 = lanhan.getInstance();
        lanhan instance2 = lanhan.getInstance();
        System.out.println(instance1==instance2);

    }

}

四、静态内部类

可以延时加载，并且线程安全

//静态内部类实现
public class Holder {
    //构造器私有
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    //静态内部类
    public static class InnerClass{
    private static final Holder HOLDER = new Holder();
    }

    public static void main(String[] args) {
        Holder instance = Holder.getInstance();
        Holder instance2 = Holder.getInstance();
        System.out.println(instance==instance2);
    }

}

五、反射破坏单例模式

java中存在反射机制，能够改变内部的private关键字，因此使用private修饰的其实都不算是安全的，由此引出枚举单例模式。

//反射破坏单例模式
public class fanshe {
    //构造器私有
    private fanshe(){
        System.out.println(Thread.currentThread().getName()+"OK");
    }

    private static volatile fanshe lazyMan;

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

    public static void main(String[] args) throws Exception {
        fanshe instance = fanshe.getInstance();
        //利用反射获取其对应的构造器方法
        Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null);
        //无视私有构造器，通过反射创建对象
        declaredConstructor.setAccessible(true);
        fanshe instance2 = declaredConstructor.newInstance();

        System.out.println(instance==instance2);

    }
}

如何解决反射破坏单例现象？第一种方法，我们可以在构造器里面对类加锁。

//反射破坏单例模式
public class fanshe {
    //构造器私有
    private fanshe(){
       synchronized (fanshe.class){
           if(lazyMan==null){
               throw new RuntimeException("不要试图使用反射破坏异常");
           }
       }
    }

    private static volatile fanshe lazyMan;

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

    public static void main(String[] args) throws Exception {
        fanshe instance = fanshe.getInstance();
        //利用反射获取其对应的构造器方法
        Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null);
        //无视私有构造器，通过反射创建对象
        declaredConstructor.setAccessible(true);
        fanshe instance2 = declaredConstructor.newInstance();

        System.out.println(instance==instance2);

    }

}

但是上面那种方法治标不治本，因为第一个instance我们是通过getInstance方法创建的，没经过反射，如果我们两个对象都是通过反射创建，如下代码所示，还是会存在问题。

//反射破坏单例模式
public class fanshe {
   //构造器私有
    private fanshe(){
       synchronized (fanshe.class){
           if(lazyMan!=null){
               throw new RuntimeException("不要试图使用反射破坏异常");
           }
       }
    }

    private static volatile fanshe lazyMan;

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

    public static void main(String[] args) throws Exception {
        //fanshe instance = fanshe.getInstance();
        //利用反射获取其对应的构造器方法
        Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null);
        //无视私有构造器，通过反射创建对象
        declaredConstructor.setAccessible(true);
        fanshe instance2 = declaredConstructor.newInstance();
        fanshe instance3 = declaredConstructor.newInstance();
        System.out.println(instance3==instance2);

    }
}

由此引入第二种方法，通过定义一个信号量来解决：

//反射破坏单例模式
public class fanshe {

    //定义一个信号量
    private static boolean flag = false;

    //构造器私有
    private fanshe(){
       synchronized (fanshe.class){
           //通过反射的方式无法获取到这个信号量，因此不能通过反射创建
           if(flag==false){
               flag=true;
           }
          else{
               throw new RuntimeException("不要试图使用反射破坏异常");
           }
       }
    }

    private static volatile fanshe lazyMan;

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

    public static void main(String[] args) throws Exception {
        //fanshe instance = fanshe.getInstance();
        //利用反射获取其对应的构造器方法
        Constructor<fanshe> declaredConstructor = fanshe.class.getDeclaredConstructor(null);
        //无视私有构造器，通过反射创建对象
        declaredConstructor.setAccessible(true);
        fanshe instance2 = declaredConstructor.newInstance();
        fanshe instance3 = declaredConstructor.newInstance();
        System.out.println(instance3==instance2);

    }

}

六、枚举单例

利用枚举的方式创建单例模式，可以避免反射对其内部进行关键字的破坏，继而导致单例模式失效。它的缺点也是不能延时加载

public enum meiju{
    INSTANCE;
    public meijugetInstance(){
        return INSTANCE;
    }
}
class test05{
    public static void main(String[] args) {
        meijuinstance1 = SingletonTest05.INSTANCE;
        meijuinstance2 = SingletonTest05.INSTANCE;
        System.out.println(instance1==instance2);
    }
}
但求上进
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-单例模式几种写法
11-29
自己总结的6中单例模式的写法，也有测试类，可以试验下，自己稍微修改一下后，验证安全性，纯粹为学习，建议可提
Java：单例模式的七种写法
12-22
枚举在Java中是一个特殊的语法结构，它天然支持单例模式，INSTANCE是Singleton枚举类型下的一个元素，相当于单例的实例，通过Singleton.INSTANCE可以直接访问到单例。此外，枚举的写法简洁明了，易于理解和维护。 ...
Five ways to Create a Singleton -单例模式的五种写法
johnny_niu的博客
08-24 199
基本介绍 单例模式（Singleton）应该是大家接触的第一个设计模式，其写法相较于其他的设计模式来说并不复杂，核心理念也非常简单：程序从始至终只有同一个该类的实例对象。 举一个耳熟能详的例子，比如 LOL 中的大龙，一场游戏下来无论如何只有一只，所以该类只能被实例化一次。再举一个我们应用程序开发中常见的例子，Spring 框架中的 Bean 作用范围默认也是单例的。 我相信大家都知道单例的两种最基本的写法：饿汉式和懒汉式。但是这两种写法都有其弊端所在，除了这两种写法外其实还有几种写法。此时耳边仿佛听到孔乙
面试题单例模式的五种写法(枚举妙用)
aiailingfei的博客
01-24 1214
单例模式的五种写法 饿汉模式:利用关键字初始化加载。 懒汉模式:用到时在加载。 双重校验:关键字volatile不能少防止指令重排。 内部类：我中有你你中有我。 枚举：特性。 枚举妙用大家都知道。 茫茫人海中寻志同道合同学。。。。。。。。
Java设计模式之单例模式的七种写法
07-13
Java设计模式之单例模式的七种写法 单例模式是一种常见的设计模式，它确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机的驱动程序对象常...
简单了解python单例模式的几种写法
09-19
主要介绍了简单了解python单例模式的几种写法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
IOS 中两种单例模式的写法实例详解
08-30
在iOS开发中，单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在Objective-C中，有两种官方推荐的单例模式实现方式，这两种方法都保证了单例对象的线程安全。以下是这两种写法的...
设计模式--单例模式的5种写法
wxhcr912的博客
08-26 380
第一种，懒汉式 //1.单例模式--懒汉式 class Singleton1{ /* 类初始化的时候不加载这个对象，真正使用的时候再创建此对象，延时加载（懒加载 lazy load） */ private static Singleton1 instance=null; private Singleton1(){} /* 保证线程安全，方法...
Java单例模式的五种写法
wjxbj的博客
02-08 141
        在网上看到《单例模式的七种写法》，写的非常好，于是转载过来学习学习，在此我按原博客一位读者同学的分类，分成懒汉、恶汉、静态内部类、枚举和双重校验锁五种。         第一种（懒汉，线程安全）： public class Singleton { private static Singleton instance; private Singl...
2 单例模式（五种写法）
one_chao的博客
10-07 117
2 单例模式（五种写法） I.保证系统中一个类只能有一个实例，需要单例模式 e.g. 缓存池，数据连接池，应用实例 饿汉（线程安全） 懒汉 I.线程不安全 II.线程安全 双重校验锁 静态内部类 枚举 ...
单例模式5种常见写法
javaskyhr的专栏
09-26 889
今天总结一下单利模式，平常用的也比较多，但是深入研究还是最近一段时间，学习总结，单利目前有以下几种写法 饿汉式单例： 饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线 程还没出现以前就是实例化了，不可能存在访问安全问题。 优点:没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。 缺点:类加载的时候就初始化，不管用与不用都占着空间，浪费了内存。 写法如...
设计模式之单例模式的几种写法
caizehui的博客
01-23 480
单例模式是初级程序员知道的唯一的设计模式，但是就是一个简单的单例模式也有很多的写法，而且不同的写法有不同的优缺点，我们开发使用时可能看到别人怎么写，我们就怎么写，实际上还是有很多原理性的东西需要我们去学习，了解不同写法的原理和优缺点。 单例模式介绍： 单例模式是应用最广的模式之一，应用时，单例对象的类必须保证只有一个实例存在。 定义： 确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实...
双检锁单例模式的写法
最新发布
09-22
双检锁/双重校验锁（DCL）是一种线程安全的懒汉式单例模式。其写法如下所示： ```java public class Singleton { private volatile static Singleton singleton; private Singleton(){} public static Singleton getSingleton() { if(singleton == null) { synchronized (Singleton.class) { if(singleton == null) singleton = new Singleton(); } } return singleton; } } ``` 在这个例子中，使用了双重检查来保证只有在第一次调用`getSingleton()`方法时才创建实例。使用`volatile`关键字修饰`singleton`变量可以确保多个线程正确处理该变量的可见性和有序性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值