【JAVA实现】单例模式（singleton）

最新推荐文章于 2023-07-11 21:27:54 发布
最新推荐文章于 2023-07-11 21:27:54 发布
阅读量803 收藏
点赞数 1
分类专栏： 设计模式 java 文章标签： 单例模式 java singleton
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_son/article/details/51136790
版权

一  定义

保证一个类只有仅有一个实例，并提供一个访问它的全局访问点。

二  案例

一个很简单的案例，读取配置文件，这里读取properties文件。

三  未使用模式的情况

很容易写出如下代码： 
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 *
 * Created by jerry on 16-4-12.
 */
public class AppConfig {

    private String parameterA;
    private String parameterB;

    public AppConfig() {
        readConfig();
    }

    private void readConfig() {
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = AppConfig.class.getResourceAsStream("AppConfig.properties");
            prop.load(in);
            this.parameterA = prop.getProperty("paraA");
            this.parameterB = prop.getProperty("paraB");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public String getParameterA() {
        return parameterA;
    }

    public String getParameterB() {
        return parameterB;
    }

}
/**
 * Created by jerry on 16-4-12.
 */
public class Client {
    public static void main(String[] args) {
        AppConfig config = new AppConfig();

        String paraA = config.getParameterA();
        String paraB = config.getParameterB();
        System.out.println(paraA);
        System.out.println(paraB);
    }
}

# 配置文件 AppConfig.properties 
paraA = a
paraB = b
试想：如果我在整个项目中有多处地方需要用到AppConfig 对象，不断的new会使得内存中存在多个实例。如果配置文件很小，那么影响不会很大，但是如果配置文件中内容特别多的话，那么将会占据很多资源。而事实上，AppConfig功能仅仅是读取配置文件而已，只需要一个实例对象就够了。

四  使用模式的情况

单例模式的写法很简单。只需分为3个步骤：
  1. 将构造函数私有化
  2. 创建一个类的实例的静态变量
  3. 提供一个返回类实例的静态方法
单例模式又分为 懒汉式 和 饿汉式。下面一一介绍。 
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 懒汉式
 * Created by jerry on 16-4-12.
 */
public class AppConfig_Lazy {

    private String parameterA;
    private String parameterB;

    private static AppConfig_Lazy instance = null;

    public static AppConfig_Lazy getInstance() {
        //首先判断实例有没有初始化
        if (instance == null){
            //如果没有初始化那么new一个实例
            instance = new AppConfig_Lazy();
        }
        return instance;
    }

    private AppConfig_Lazy() {
        readConfig();
    }

    private void readConfig() {
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = AppConfig_Lazy.class.getResourceAsStream("AppConfig.properties");
            prop.load(in);
            this.parameterA = prop.getProperty("paraA");
            this.parameterB = prop.getProperty("paraB");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public String getParameterA() {
        return parameterA;
    }

    public String getParameterB() {
        return parameterB;
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 饿汉式
 * Created by jerry on 16-4-12.
 */
public class AppConfig_Hungry {

    private String parameterA;
    private String parameterB;

    private static AppConfig_Hungry instance = new AppConfig_Hungry();

    public static AppConfig_Hungry getInstance() {
        return instance;
    }

    private AppConfig_Hungry() {
        readConfig();
    }

    private void readConfig() {
        Properties prop = new Properties();
        InputStream in = null;
        try {
            in = AppConfig_Hungry.class.getResourceAsStream("AppConfig.properties");
            prop.load(in);
            this.parameterA = prop.getProperty("paraA");
            this.parameterB = prop.getProperty("paraB");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public String getParameterA() {
        return parameterA;
    }

    public String getParameterB() {
        return parameterB;
    }

}
其实两者差别仅在于前几行， 懒汉式：实例的初始化等到客户端需要创建实例的时候才需要new。饿汉式：只要类加载器一加载类，就进行初始化。
如果对性能要求不是特别苛刻，那么还是推荐使用饿汉式，写起来特别方便。当需要写懒汉式时，必须要注意的是 线程安全性，上述的写法为线程不安全，例如有两个线程同时访问getInstance方法，当其中一个线程刚判断 instance==null 完，进入if语句里，但没有执行instance = new AppConfig_Lazy();时，另一个线程开始判断if语句内容，发现instance为空，也将进入if语句里。那么之后会进行两次的new操作，即将会创建两个实例，不会达到单例的目的。
当然，需要修改为线程安全也很简单，只需在方法上加入synchronized 关键字即可。 
public static synchronized AppConfig_Lazy getInstance() {
        //首先判断实例有没有初始化
        if (instance == null){
            //如果没有初始化那么new一个实例
            instance = new AppConfig_Lazy();
        }
        return instance;
    }
但是如果这样进行同步，会大大降低访问速度，因为每次获取实例都要同步。更好的做法是采用“双重检查加锁”法。

五  使用 “双重检查加锁法” 改写懒汉式

双重检查加锁法实现需要用到一个关键字  volatile  ，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操纵内存，从而确保多个线程能正确处理该变量。 
private volatile static AppConfig_Lazy instance = null;

    public static AppConfig_Lazy getInstance() {
        //首先判断实例有没有初始化
        if (instance == null){
            //同步块，线程安全地创建实例
            synchronized (AppConfig_Lazy.class) {
                // 再次检查实例是否存在，如果不存在才真正创建实例
                if (instance == null)
                    instance = new AppConfig_Lazy();
            }
            instance = new AppConfig_Lazy();
        }
        return instance;
    }
所谓双重检查加锁是指：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，先检查实例是否已经创建，这是第一次检查。如果未创建，则进入下面的同步块，进入同步块后再检查实例是否创建，这是第二次检查。这样就创建了一个线程安全的单例模式。

六  进阶的单例模式

有时我们会想，我觉得一个实例太少，可能满足不了需求，我想要控制3个实例。
可以使用Map来缓存实现单例。说到缓存，其实我们之前介绍的懒汉式单例中也用到了缓存技术，即只有第一次访问才会创建对象，其他情况读取内存即可，不过缓存中只有一个对象而已。当使用Map来实现时，就可以控制任意数量的实例。这时新的问题来了，当客户端调用的时候，我该返回哪一个实例呢？这里又设计到调度的问题，这里就不继续介绍了，具体问题具体分析。
以下的代码线程不安全，若要其成为线程安全，可参考之前做法。 
import java.util.HashMap;
import java.util.Map;

/**
 * 简单演示扩展的单例模式，创造3个实例
 * TODO 扩展调度算法
 * Created by jerry on 16-4-12.
 */
public class SingletonExtend {
    /**
     * 定义一个缺省的key前缀
     */
    private final static String DEFAULT_PREKEY = "Cache";
    /**
     * 缓存实例的容器
     */
    private static Map<String, SingletonExtend> map = new HashMap<String, SingletonExtend>();
    /**
     * 用来记录当前第几个实例
     */
    private static int num = 1;
    /**
     * 最大实例个数
     */
    private final static int MAX_NUM = 3;

    private SingletonExtend() {
    }

    public static SingletonExtend getInstance() {
        String key = DEFAULT_PREKEY + num;
        SingletonExtend singletonExtend = map.get(key);
        if (singletonExtend == null) {
            singletonExtend = new SingletonExtend();
            map.put(key, singletonExtend);
        }
        ++num;
        if (num > MAX_NUM)
            num = 1;

        return singletonExtend;
    }

    public static void main(String[] args) {
        SingletonExtend s1 = getInstance();
        SingletonExtend s2 = getInstance();
        SingletonExtend s3 = getInstance();
        SingletonExtend s4 = getInstance();
        SingletonExtend s5 = getInstance();
        SingletonExtend s6 = getInstance();

        System.out.println("s1="+s1);
        System.out.println("s2="+s2);
        System.out.println("s3="+s3);
        System.out.println("s4="+s4);
        System.out.println("s5="+s5);
        System.out.println("s6="+s6);
    }
}
程序运行结果如下：

七  总结

何时选用单例模式

  1. 当需要控制一个类的实例只有一个时，而且客户只能通过从一个全局访问点访问它，这时可以考虑选用单例模式。
------------------------------------------------------------------------------------------------------------------------------------------
Reference：《研磨设计模式》


C_son
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现单例设计模式方法解析
08-19
Java实现单例设计模式方法解析 单例设计模式是软件设计模式中的一种，旨在确保一个类只有一个实例，并提供一个全局访问点。Java中有多种方式可以实现单例设计模式，本文将对这些方法进行解析，并提供示例代码。 一...
Java设计模式单例模式(Singleton)用法解析
08-25
Java设计模式单例模式（Singleton）用法解析 java设计模式单例模式（Singleton）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局反访问点。单例模式是创建型模式。单例模式在生活中应用也很广泛，...
使用Java实现单例模式
m0_59996263的博客
02-20 731
很明显,虽然benzCar和benzCar1的属性都是"奔驰"和"小叮当",但是他们的hashcode却不相等,这意味着,在计算机(jvm)看来,实际上他们创建了两个对象.占用了两份内存.实际小叮当只有一辆车,计算机模型和真实世界的模型不一致了.会导致程序出现问题.如何解决这个问题呢?
JAVA设计模式之单例模式（6种实现）
孔子说
11-19 827
转自http://www.kongzid.com/archives/design2，单例对象的类只能允许一个实例存在。 许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。 单例的实现主要是通过以下两个步骤： 将该类的构...
Java 实现单例模式的七种写法
大帅的博客
09-10 6218
单例模式（Singleton Pattern） 是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
Java 实现一个单例模式_单例模式的 Java 实现与思考
weixin_33378701的博客
02-24 453
一、摘要本文对单例模式在 Java 里的不同实现方式进行了分析，对比了不同方案的优缺点并给出使用结论。二、单例模式的实现单例模式的要义是控制某一个类只有一个唯一的实例，并提供一个统一的访问点。它主要用在某些不希望有多个实例的场景，比如线程池。1.基础实现首先来看一个单例模式的基础实现:public class Singleton {private static final Singleton in...
设计模式之单例模式
u011028777的专栏
11-25 1037
定义               单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例   优缺点 优点 一、实例控制       单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。 二、灵活    因为类控制了实例化过程，所以类可以灵活更改实例化
Java实现多种单例模式
11-30
以下是Java实现的六种单例模式的详细解释： 1. 懒汉式（Lazy Initialization）： 这种方式延迟了单例对象的初始化，直到第一次被请求时。例如，`SingleInstance1.java`可能就实现了这种方式。代码通常包含一个私有...
java单例模式实例
07-17
在Java中，有多种实现单例模式的方法，每种都有其特点和适用场景。接下来，我们将深入探讨这些实现方式。 首先，我们来看**懒汉式（Lazy Initialization）**。这种实现方式是在类被首次请求时才创建单例对象，延迟...
Java 单例模式Singleton
01-08
简单的单例模式举例Singleton 分为恶汉式 懒汉式
Java实现设计模式之——单例模式
执梗的博客
03-22 1610
Java实现设计模式之——单例模式
java：单例模式的五种实现方式
基地的博客
05-23 8572
基于java实现到单例模式
java设计模式-单例模式（Singleton）
听海边涛声
07-11 1652
java设计模式-单例模式（Singleton）
Java设计模式--单例模式（三种实现方式）
YoungJIA977的博客
07-11 1060
单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式。简单来说保证在内存中有给定数量的对象，例如内存中产生唯一一个对象，不管创建多少次，也只有唯一的对象。
java中单例模式的实现
薯条和番茄酱的博客
03-22 318
什么是单例模式？单例模式是java设计模式的一种，这个模式的目的就是保证某一个类只有一个实例存在。比如我们java中的DataSource数据源就是需要只有一个实例，是单例模式的一种实现。单例模式由于在内存中只有一个实例，减少了内存的开销，当我们频繁的创建和销毁实例时，并且该模式还能避免对资源的多重占用。单例模式中我们主要分为饿汉模式和懒汉模式，以下介绍这两种模式以及实现方式。
JAVA编写单例（Singleton）模式
假娃的博客
06-28 518
单例（Singleton）模式：在Java应用程序中，一个类Class只有一个实例存在。 第一种写法形式（饿汉式）: 定义一个类，它的构造函数为private的，它有一个private的static的该类变量，在类初始化时实例化，通过public的getInstance方法获取对它的引用,继而调用其中的方法。 Public class Singleton { //私有化构造函数 private...
Java中Singleton的三种实现方式解析
pedro7k的博客
02-20 377
一、什么是Singleton？ 《设计模式》的作者、Eclipse和Junit的开发者Erich Gamma在它的理论体系中将Singleton定义为仅仅被实例化一次的类。在当今面向对象程序的实际开发中，Singleton通常被用来代表一个无状态的对象，例如函数和那些本质上唯一的系统组件。 值得注意的是，使类成为Singleton会使得它的客户端测试变得非常困难，因为我们不可能给Singleton替换模拟实现，除非我们实现一个充当其类型的接口。 实现Singleton有三种常见方法，他们或是保持构造器私有并
（Singleton）单例模式的Java实现
weixin_33709609的博客
06-14 129
单例模式（Singleton）：当系统中只需要的某个类的唯一对象时，可以使用该模式。 为什么会用到该模式？因为有时候某些对象的创建需要耗费大量的资源、使用单一（唯一）的对象实例来维护某些共享数据等，在这些场景下即可采用单例模式进行设计，可以适当地渐少内存开销，因为此时该唯一对象不会（被限制了）频繁地创建。 一个简单单例类图如下： 代码实现如下： 单例类Sing...
很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 如果客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置 文件内容的对象，则在系统运行中，有 很多地方都需
weixin_43899069的博客
11-25 1794
  很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。   如果客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象，则在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。   事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用Java控制台应用程序实现该单例模式。绘制该模式的UML图。 代码一：AppConfig.java public class
java 实现单例模式
最新发布
07-13
在Java中，可以使用以下代码实现单例模式： ```java public class Singleton { private static Singleton instance; // 私有构造方法，防止外部实例化对象 private Singleton() { } // 静态方法获取单例对象 public static Singleton getInstance() { if (instance == null) { // 使用同步锁确保线程安全 synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` 在上述代码中，我们定义了一个私有的静态变量 `instance`，用于保存单例对象。构造方法 `Singleton()` 被私有化，使得该类无法在外部被实例化。通过静态方法 `getInstance()` 获取单例对象，如果 `instance` 为 null，则通过同步锁创建一个新的实例，否则直接返回现有的实例。 这种实现方式被称为“懒汉模式”，它延迟了对象的创建，只有在第一次调用 `getInstance()` 方法时才会创建实例。使用同步锁能够确保在多线程环境下只有一个线程能够创建实例，从而保证单例的唯一性。 请注意，这种实现方式在性能上存在一些开销，因为每次调用 `getInstance()` 方法都需要进行同步锁的判断。如果对性能要求较高，可以考虑使用饿汉模式或者静态内部类的方式实现单例模式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值