Java设计模式—单例模式

文章目录

• 前言
• 一、举例说明单例模式
• • 1.、程序代码
  • • ①、皇帝类
    • ②、臣子类
    • ③、运行结果
    
    
  
  
• 二、单例模式的定义
• • 1、单例模式通用类图
  • 2、单例模式通用代码
  
  
• 三、单例模式的应用
• • 1、单例模式的优点
  • 2、单例模式的缺点
  • 3、单例模式的使用场景
  • 4、单例模式的注意事项
  • • ①、线程不安全的懒汉式单例模式
    • ②、线程安全的懒汉式单例模式
    • ③、饿汉式单例模式
    • ④、懒汉式单例模式和饿汉式单例模式比较
    
    
  
  
• 总结

开始学习Java设计模式时第一个学习的模式是单例模式，参考书籍为《设计模式之禅》第2版，在此做一个记录以及学习心得，便于以后进行回顾

提示：以下是本篇文章正文内容，下面案例可供参考

在古代大家谈论的时候只要提及皇帝，每个人都知道指的是谁，不需要在皇帝前面加上特定的称呼。这个过程反映到设计领域就是要求一个类只能生成一个皇帝，所有的对象对它的依赖都是相同的。接下来将这个场景用程序来实现

1.、程序代码

①、皇帝类

public class Emperor {
// 在皇帝类内部初始化一个皇帝
private static final Emperor emperor = new Emperor();
// 设置构造方法为private防止其它类再生成另一个皇帝
private Emperor(){
}
// 定义外部获取到该类对象的唯一方法
public static Emperor getInstance(){
return emperor;
}
// 皇帝开始说话了
public static void say(){
System.out.println("我就是皇帝XXX");
}
}


通过定义一个私有访问权限的构造函数，避免被其他类new出来一个对象，而Emperor自己则可以new出一个对象来，其他类对该类的访问都可以通过getInstance()获得同一个对象。

②、臣子类

public class Minister {
public static void main(String[] args) {
// 模拟一个上朝的场景，臣子连续三天上朝叩拜皇帝
for (int day = 0;day <3;day++){
// 记录臣子第几天上朝叩拜皇帝
System.out.println("<--------第" + (day + 1) + "天上朝-------->");
// 臣子叩拜皇帝时说的话
System.out.println("吾皇万岁万岁万万岁");
// 开始获取到皇帝对象
Emperor emperor = Emperor.getInstance();
// 皇帝开始说话了
emperor.say();
}
}
}


③、运行结果

单例模式：
Ensure a class has only one instance, and provide a global point of access to it.
（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例）
单例模式属于创造类型设计模式

1、单例模式通用类图

类图解析：

Single类为单例类，通过使用private的构造函数确保了在某一个应用中只产生一个实例，（构造方法为private时无法在其他类中通过new关键字实例该类的对象），并且在Singleton类中自行完成实例化

自行实例化代码：

private static final Singleton singleton = new Singleton();


2、单例模式通用代码

public class Singleton {
// 在类的内部将本类的对象自行实例化
private static final Singleton singleton = new Singleton();

// 将构造方法访问权限设置为private来限制产生多个对象
private Singleton(){
}

// 外界只能通过该方法获得实例对象
public static Singleton getSingleton(){
return singleton;
}

// 本类中的其它方法，尽量为static
public static void doSomething(){
}
}


1、单例模式的优点

1. 单例模式在内存中只有一个实例，因此减少了内存的开支，特别是当一个对象需要频繁地创建、销毁而且创建或销毁时性能又无法优化时单例模式的优势就很明显了。
2. 由于单例模式值生成一个实例，所以系统的性能开销被大大的降低，当一个对象的产生需要比较多的资源时，例如读取配置、产生其他依赖对象时，在可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（在JavaEE中采用单例模式时应当注意JVM垃圾回收机制）。
3. 单例模式可以避免对资源的多重占用，例如在写一个文件时由于内存中只有一个实例存在，因此对这一个资源文件加锁后可以避免对同一个资源文件的同时写操作。
4. 单例模式可以在系统设置全局访问点，优化和共享资源访问，例如可以设计一个单例类来负责所有数据表的映射处理。

2、单例模式的缺点

1. 单例模式一般不是接口，因此扩展很困难，如果要进行扩展的话，除了修改原本类中的代码外基本上没有第二种方法可以实现扩展。这个违反了开闭原则（对扩展开放，对修改关闭。意思是可以在类的基础上扩展代码，但是不能修改原有的代码）。在这里要注意一个问题：为什么单例模式一般不是接口？答：因为在单例模式中，是要求自行实例化并且提供单一实例，然而接口和抽象类是不可能被实例化的，因此接口和抽象类对单例模式来说没有任何意义。
2. 单例模式对测试是不友好的。在并行开发的环境中，如果单例模式没有完成，是不能进行测试的。
3. 单例模式与单一职责原则有冲突。在Java设计模式中一个类应该只实现一个逻辑，而单例模式则将多种业务逻辑融合在了一个类中，因此是否采取单例模式要取决于实际环境。

3、单例模式的使用场景

通常在一个系统中，要求某些类有且仅有一个对象。如果出现多个对象就会出现一些不必要的问题时可以采用单例模式

1. 要求生成唯一序列号的环境
2. 在整个项目中需要一个共享访问点或共享数据，例如一个前端页面上的计数器，不需要把每一次刷新都记录到数据库中，使用单例模式保持计数器的值，还可以确保线程是安全的。
3. 创建一个对象需要消耗的资源过多，例如要访问IO和数据库等资源时可以使用单例模式
4. 需要定义大量的静态常量以及静态方法的环境，例如需要定义大量工具类的环境也可以采用单例模式

4、单例模式的注意事项

①、线程不安全的懒汉式单例模式

在非高并发（低并发）的情况下，单例模式不会出现产生多个实例的问题。但是在高并发的情况下，使用单例模式就需要考虑进程同步的问题。

例如下列代码：

public class Singleton {
// 在类的内部将本类的对象自行实例化
private static Singleton singleton = new Singleton();
// 将构造方法访问权限设置为private来限制产生多个对象
private Singleton(){
}
// 外界只能通过该方法获得实例对象
public static Singleton getSingleton(){
if (singleton == null){
singleton = new Singleton();
}
return singleton;
}
}


在这段单例模式的代码中，如果在高并发的情况下会出现危险。

if (singleton == null){
singleton = new Singleton();
}


原因：
在高并发的场景下，如果一个线程A执行到singleton = new Singleton()，但是此时还没有获取到对象（对象的初始化是需要时间的），假设在这同一时间第二个线程B执行到了(singleton == null)判断，那么线程B获得的判断条件也是真，也是单例对象还不存在，于是继续运行下去，线程A和线程B都获得了一个对象，在内存中就出现了两个对象。

因此为了解决这种线程不安全的情况，可以在getSingleton方法前加synchronized关键字，也可以在getSingleton方法内部增加synchronized关键字来实现。

所以就引出了多线程安全的两种单例模式：懒汉式单例模式和饿汉式单例模式

②、线程安全的懒汉式单例模式

public class Singleton {
// 在类的内部将本类的对象自行实例化
private static Singleton singleton = new Singleton();
// 将构造方法访问权限设置为private来限制产生多个对象
private Singleton(){
}
// 外界只能通过该方法获得实例对象
public static synchronized Singleton getSingleton(){
if (singleton == null){
singleton = new Singleton();
}
return singleton;
}
// 本类中的其它方法，尽量为static
public static void doSomething(){
}
}


正如之前提到过解决多线程的方法，多线程安全的懒汉式单例模式通过加锁有效的避免了在内存中产生多个对象的问题，所以这种懒汉式单例模式的线程是安全的，并且第一次调用时才初始化，很好的避免了内存浪费。但是懒汉式单例模式必须加锁synchronized才能保证单例，但加锁会影响效率。

③、饿汉式单例模式

public class Singleton {
// 在类的内部将本类的对象自行实例化
private static Singleton singleton = new Singleton();
// 将构造方法访问权限设置为private来限制产生多个对象
private Singleton(){
}
// 外界只能通过该方法获得实例对象
public static Singleton getSingleton(){
return singleton;
}
// 本类中的其它方法，尽量为static
public static void doSomething(){
}
}


饿汉式单例模式在类加载时就初始化，会浪费内存。但是相反地，因为饿汉式单例模式没有加锁，执行效率会提高。

④、懒汉式单例模式和饿汉式单例模式比较

       以上便是Java设计模式中的第一个单例模式，单例模式是23个模式中比较简单的模式，应用也特别广泛。例如在Spring中，每个Bean默认就是单例的，这样做得有点就是Spring容器可以管理这些Bean的声明周期，可以自由的决定什么时候将Bean创建出来，什么时候销毁Bean、销毁的时候要如何处理等。