java单例模式

最新推荐文章于 2024-06-06 20:35:43 发布
最新推荐文章于 2024-06-06 20:35:43 发布
阅读量144 收藏
点赞数
分类专栏： java 设计模式 文章标签： 单例模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44178366/article/details/129149728
版权

单例模式

单例模式基本分为两种：饿汉式和饱汉式

还有一些比较好玩的值得研究的场景。

饿汉式

package com.pihao.main.single;

/**
 * 饿汉式 
 */
public class HungryMan {

    private HungryMan(){
    }
    private static HungryMan hungryMan = new HungryMan();

    private static HungryMan getInstance(){
        return hungryMan;
    }

    //思考：这种写法在该对象还没使用的时候就要先去加载庞大的资源，造成浪费
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];

}

饱汉式/懒汉式

package com.pihao.main.single;

/**
 * 饱汉式、懒汉式
 */
public class FullMan {
    private FullMan(){
    }
    private static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            //要用的时候再去加载new
            fullMan = new FullMan();
        }
        return fullMan;
    }

}

单例模式的安全性验证

package com.pihao.main.single;

/**
 * 饱汉式、懒汉式
 */
public class FullMan {
    private FullMan(){
        System.out.println(Thread.currentThread().getName() + "启动了");
    }
    private static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            //要用的时候再去加载
            fullMan = new FullMan();
        }
        return fullMan;
    }

    //上述代码在单线程下没问题的,但是在多线程的场景下如果保证单例呢？

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


//执行效果如下：
Thread-1启动了
Thread-2启动了
Thread-0启动了

结论：在并发的情况下，懒汉式的单例模式是有问题的，不能保证获取到的是同一个对象。
解决办法：上锁

双重检测锁模式的懒汉式单例----DCL懒汉式

package com.pihao.main.single;

/**
 * 饱汉式、懒汉式
 */
public class FullMan {
    private FullMan(){
        System.out.println(Thread.currentThread().getName() + "启动了");
    }
    //使用volatile关键字，防止指令重排
    private volatile static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            //加锁
            synchronized (FullMan.class){
                if(fullMan == null){
                    //要用的时候再去加载
                    fullMan = new FullMan();
                }
            }
        }
        return fullMan;
    }

    //上述代码在单线程下没问题的,但是在多线程的场景下如果保证单例呢？

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


//执行效果如下：
Thread-0启动了

结论：在常规并发的情况下，只能获取到同一个对象。解决了上述的问题

静态内部类

package com.pihao.main.single;

public class Outer {
    private Outer(){
    }
    public static Outer getInstance(){
        return InnerClass.OUTER;
    }
    
    public static class InnerClass{
        private static final Outer OUTER = new Outer();
    }
}

利用反射破坏单例

package com.pihao.main.single;

import java.lang.reflect.Constructor;

/**
 * 饱汉式、懒汉式
 */
public class FullMan {
    private FullMan(){
    }
    private volatile static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            synchronized (FullMan.class){
                if(fullMan == null){
                    //要用的时候再去加载
                    fullMan = new FullMan();
                }
            }
        }
        return fullMan;
    }

    //利用反射破坏单例
    public static void main(String[] args) throws Exception {
        FullMan instance1 = FullMan.getInstance();
        //无参构造
        Constructor<FullMan> constructor = FullMan.class.getDeclaredConstructor(null); 
        constructor.setAccessible(true);
        FullMan instance2 = constructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//输出为
1163157884
1956725890
说明创建了两个不同的对象，单例不安全，怎么解决呢？

//上述问题解决办法
package com.pihao.main.single;

import java.lang.reflect.Constructor;

/**
 * 饱汗式、懒汉式
 */
public class FullMan {
    private FullMan(){
        synchronized (FullMan.class){
            if(fullMan != null){
                throw  new RuntimeException("非法构建对象！");
            }
        }
    }
    private volatile static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            synchronized (FullMan.class){
                if(fullMan == null){
                    //要用的时候再去加载
                    fullMan = new FullMan();
                }
            }
        }
        return fullMan;
    }
}

继续进阶

上述代码是一个new 对象，一个利用反射来创建的对象，那么如果我两个对象都是用反射来创建的呢？还会是同一个值吗？

package com.pihao.main.single;

import java.lang.reflect.Constructor;

/**
 * 饱汗式、懒汉式
 */
public class FullMan {
    private FullMan(){
        synchronized (FullMan.class){
            if(fullMan != null){
                throw  new RuntimeException("非法构建对象！");
            }
        }
    }
    private volatile static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            synchronized (FullMan.class){
                if(fullMan == null){
                    //要用的时候再去加载
                    fullMan = new FullMan();
                }
            }
        }
        return fullMan;
    }

    //利用反射破坏单例
    public static void main(String[] args) throws Exception {
        Constructor<FullMan> constructor = FullMan.class.getDeclaredConstructor(null); //无参构造
        constructor.setAccessible(true);
        FullMan instance1 = constructor.newInstance();
        FullMan instance2 = constructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//输出为
1163157884
1956725890

发现又创建了两个不同的对象，怎么解决呢？可以添加一个属性，类似红绿灯的方式

package com.pihao.main.single;

import java.lang.reflect.Constructor;

/**
 * 饱汗式、懒汉式
 */
public class FullMan {
    private static boolean flag = false;
    private FullMan(){
        synchronized (FullMan.class){
            if(flag == false){
                flag = true;
            }else{
                //进来两次就报错
                throw  new RuntimeException("非法构建对象！");
            }
        }
    }
    private volatile static FullMan fullMan;

    public static FullMan getInstance(){
        if(fullMan == null){
            synchronized (FullMan.class){
                if(fullMan == null){
                    //要用的时候再去加载
                    fullMan = new FullMan();
                }
            }
        }
        return fullMan;
    }

    //利用反射破坏单例
    public static void main(String[] args) throws Exception {
        Constructor<FullMan> constructor = FullMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        FullMan instance1 = constructor.newInstance();
        FullMan instance2 = constructor.newInstance();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//使用上述的标志后确实可以解决多次反射创建对象的问题，但是。。。。。。

思考：在第一次使用反射创建完instance1对象之后，是否可以利用反射将属性flag 的值重新设置为false，那么之后又可以创建instance2对象了。。。道高一尺，魔高一丈！

那么最终的办法是怎么解决才能保证安全呢？

枚举！！

枚举本身也是一个class类

package com.pihao.main.single;

import java.lang.reflect.Constructor;

public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return EnumSingle.INSTANCE;
    }

    public static void main(String[] args)throws Exception {
//Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(null);
//Exception in thread "main" java.lang.NoSuchMethodException: com.pihao.main.single.EnumSingle.<init>()
        //上面的报错是因为底层没有空参构造这个方法，虽然看class类有这个方法，可以使用jad反编译一下

        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        EnumSingle instance2 = constructor.newInstance();
//报错: Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    }

}

//结论：枚举类不会被反射破坏，使用枚举创建单例模式是安全的
倔强的耗子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java单例模式实例
07-17
在Java中，有多种实现单例模式的方法，每种都有其特点和适用场景。接下来，我们将深入探讨这些实现方式。 首先，我们来看**懒汉式（Lazy Initialization）**。这种实现方式是在类被首次请求时才创建单例对象，延迟...
使用Java单例模式实现一个简单的日志记录器.txt
08-17
### 使用Java单例模式实现一个简单的日志记录器 #### 一、单例模式简介 单例模式是一种常用的软件设计模式，在该模式中，一个类只能创建一个实例，并且提供了一个全局访问点来访问该实例。单例模式的主要优点包括...
Java单例模式
m0_58154870的博客
09-28 636
- 单例模式是一种常用的软件设计模式,其定义是单例模式的类只能允许一个实例存在 - 也就是说,只允许内存创建一次对象的设计模式.并提供一个获取方法以供使用.
Java 单例模式详解
兴趣是最好的老师，勤能补拙
05-09 1996
本文介绍了 Java 中所有常见的单例模式实现方式，包括懒汉式、饿汉式、枚举式、双重检查锁定式和静态内部类式。每种实现方式都有其优缺点和适用场景，大家需要根据实际情况进行选择。无论选择哪种实现方式，都应该遵循单一责任原则和开闭原则等设计原则，以确保代码具有良好的可维护性和扩展性。
深入了解Java单例模式及其使用场景
最新发布
hirezy
06-06 1113
简单通俗来讲，单例模式是一种设计模式，它确保一个类只能有一个实例，并提供全局访问。在Java中，可以通过以下几种方式来实现线程安全的单例模式。
java 单例模式 参数_Java单例模式
weixin_39967120的博客
02-18 655
再孬再好，就你一个单例模式单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。注意：单例类限制类的实例个数，保证类的实例在JVM的世界里只有一个...
java 单例模式（懒汉式与饿汉式）
08-29
Java 单例模式（懒汉式与饿汉式） Java 单例模式是一种常用的软件设计模式，在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式，...
Java单例模式简单示例
08-30
Java单例模式简单示例 Java单例模式是一种非常常用的设计模式，它可以确保某个类只有一个实例，并提供一个全局访问点。下面我们将通过一个简单的示例来介绍Java单例模式的定义和使用技巧。 单例模式的定义 单例...
Java 单例模式线程安全问题
08-29
Java 单例模式线程安全问题详解 Java 单例模式线程安全问题是指在 Java 中实现单例模式时，如何确保线程安全的问题。单例模式是指在整个应用程序生命周期中，只有一个实例存在的设计模式。这种模式可以提高性能，...
java线程池ThreadPoolExecutor详解及使用
weixin_44178366的博客
08-06 3764
java线程池ThreadPoolExecutor的使用 在日常开发中我们经常会使用多线程，但是当线程数量达到一定程度时，频繁的创建线程、执行任务、销毁线程就会造成资源的浪费和性能的开销，那么这个时候就要考虑使用线程池了，它可以很好的避免这个问题，尤其是程序中需要创建大量的生存周期很短的线程时，更应该考虑使用线程池。 线程池的概念 线程池（ThreadPool），简单的说，它就是一个装有线程的池子，我们只需把任务（多线程执行的内容）交给线程池来处理，和数据库连接池、Http连接池的概念差不多的，通过维护
MinIO的基本安装与使用
weixin_44178366的博客
12-21 2706
MinIO 业务中常常涉及文件的操作，公司服务器在上百万个面单文件的压力下常常处于高负载的边缘，于是采用了MinIO寻求解决方案！ 概述 MinIO 是一个高性能的对象存储服务，非常适合于存储大容量非结构化的数据。例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等，进而减小服务器的压力 官网 官网地址：https://min.io/ 文档地址：https://docs.min.io/ 下载地址：https://min.io/download#
java使用安全证书进行接口联调
weixin_44178366的博客
08-20 1650
java使用安全证书进行接口联调 证书导入 使用证书文件生成 .cer后缀的证书 如果对方只给到你 .p12后缀的证书， 没有给到你 .cer后缀的格式的证书，那么你就要使用 .p12后缀的生成 .cer后缀的证书，在这里，我以 xca工具为例 1、点击File，选择New DataBase，新建一个文件夹用来存放生成的cer证书文件(待会要用，所以要记住路径) 2、设置密码 3、点击 import,选择PKCS#12,找到对方提供的 .p12格式的证书文件，需要输入证书的密码，然后点击impor
ElasticSearch、ES、es使用教程
weixin_44178366的博客
02-28 1560
Elasticsearch 简介 官网学习文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.x/index.html Elasticsearch 是一个分布式可扩展的实时搜索和分析引擎,一个建立在全文搜索引擎 Apache Lucene™ 基础上的搜索引擎.当然 Elasticsearch 并不仅仅是 Lucene 那么简单： 分布式实时文件存储，并将每一个字段都编入索引，使其可以被搜索。 实时分析的分布式搜索引擎。 可
纯代码实现Oracle不同数据库之间的数据迁移
weixin_44178366的博客
11-28 920
存代码实现Oracle不同数据库之间的数据迁移 不用Oracle数据库之间数据迁移的实现，只要主表的数据发生了变化，那么就要自动同步到从库中 mvn依赖 <dependency> <groupId>commons-dbutils</groupId> <artifactId>commons-dbutils</artifactId> <version>1.7</version> </depend
webpack项目构建工具的基本使用，再也不能阻止我在码云看前端项目了！！！
weixin_44178366的博客
12-09 581
webpack的基本使用 webpack是那一个流行的前端项目构建工具（打包工具）可以解决当前web开发中所面临的浏览器不兼容js的问题 注意：在使用webpack之前需要提前安装好node.js，这个至关重要啊，中间踩了好多好多大坑，都是版本问题惹的祸。我是win7系统的，所以不能装太高版本的，你们装各自对应的就好 一、webpack初体验 在这里我基于一个简单的的项目使用 新建项目空白目录，并运行 npm init -y 命令，初始化包管理文件 package.json 新建src源代码目录
数据结构学习之树与红黑树（java1.8 hashMap底层实现）
weixin_44178366的博客
07-19 442
数据结构学习之树与红黑树 写在前头，最近在看java1.8的HashMap源码，被里面的红黑树折磨的死去活来的，又是插入，又是平衡，左旋右旋的，真的头大。特意静下心来学习红黑树的特性！！！ 概念 树（tree）是一种抽象的数据类型，用来模拟具有树状结构性质的数据集合，它是由n（n>0）个有限节点通过连接它们的边组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它根朝上，而叶朝下的。 树有很多种，向上的一个节点有多于两个子节点的树叫做多路数，而每个节点最多只有两个子节点
数据结构学习之java手写红黑树（左旋、右旋、插入后平衡）
weixin_44178366的博客
07-19 423
import com.sun.org.apache.regexp.internal.RE; import java.util.Comparator; /** * @Author PiHao * @Date 2020-07-19 18:34 * * 1、创建RbTree,定义颜色 * 2、创建内部类RbNode * 3、辅助方法定义：parentOf(RbNode)、isRed(RbNode)、isBlack(RbNode) setRed(RbNode)、setBlack(RbNode)、in
java1.8 hashMap红黑树源码解析左旋右旋，balanceInsertion，rotateLeft，rotateRight方法的实现原理
weixin_44178366的博客
07-23 416
学完了红黑树的性质，再来看hashMap源码就舒服多了，红黑树插入后自平衡的情景有很多种，在上一篇红黑色的博客中都有提到，还有就是左旋右旋的实现，这里就不再多说了，直接来撸源码。 /** * 插入平衡（分多钟情况，左旋，右旋） * @param root 当前根节点 * @param x 当前要插入的节点 * @return 返回根节点(平衡涉及左旋右旋会将根节点改变，所以需要返回最新的根节点) */ static <K,V> TreeNode<K,V> balan.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值