单例模式（Singleton Pattern）

单例模式

一、模式动机

单例模式（Singleton Pattern）是结构最简单的设计模式，它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以确保系统中一个类只有一个实例，且该实例易于被外界访问，从而方便对实例个数的控制并节约系统资源。

• 如何确保一个类只有一个实例并且这个实例易于被访问？
  

• 定义一个全局变量可以确保对象随时都可以被访问，但是不能防止实例化多个对象。（代码实现）
  
• 更好的办法是让类自身负责创建和保存它的唯一实例，并保证不能创建其他实例，并且提供一个访问该实例的方法。（机制实现）
  

模式定义

• 单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
  
• 单例模式的要点有三个：
  
  
  
  • 某个类只能有一个实例
    
  • 必须自行创建这个实例
    
  • 必须自行向整个系统提供这个实例
    
  
  
• 单例模式是一种对象创建型模式
  

三、模式结构

单例类：

1. public class Singleton {
2.     //静态私有成员变量
3.     private static Singleton instance=null;
4.         //私有构造函数
5.     private Singleton() {
6.     }
7.        //静态公有工厂方法，返回唯一实例
8.     public static Singleton getInstance() {
9.         if(instance==null)
10.             instance=new Singleton();
11.         return instance;
12.     }
13. }

复制代码

四、案例分析

案例背景

身份证

案例结构

代码实现

单例类

1. public class IdentityCardNo {
3.     private static IdentityCardNo instance = null;
4.     private String no;
6.     private IdentityCardNo() {
7.     }
9.     public static IdentityCardNo getInstance(){
11.         if (instance == null){
12.             System.out.println("第一次办理身份证，分配新号码");
13.             instance = new IdentityCardNo();instance.setNo("No10086111");
14.         }else
15.             System.out.println("重复办理身份证，获取旧号码");
17.         return instance;
18.     }
20.     public String getNo() {
21.         return no;
22.     }
24.     public void setNo(String no) {
25.         this.no = no;
26.     }
27. }

复制代码

测试类

1. public class Client {
3.     public static void main(String[] args) {
4.         IdentityCardNo no1,no2;
5.         no1 = IdentityCardNo.getInstance();
6.         no2 = IdentityCardNo.getInstance();
7.         System.out.println("身份证号码是否一致"+(no1 == no2));
9.         String str1,str2;
10.         str1 = no1.getNo();
11.         str2 = no2.getNo();
12.         System.out.println("第一次号码："+str1);
13.         System.out.println("第二次号码："+str2);
14.         System.out.println("内容是否相等："+str1.equalsIgnoreCase(str2));
15.         System.out.println("是否是相同对象："+(str1 == str2));
16.     }
18. }

复制代码

案例结果

五、模式分析

• 单例模式的实现
  
• 私有构造函数
  
• 静态私有成员变量（自身类型）
  
• 静态公有的工厂方法
  

• 单例模式的目的
  
  
  
  • 保证一个类只有一个唯一的实例，并为它提供一个全局访问点。
    
  
  
• 实现单例模式的思想
  
  
  
  • 为了防止客户端程序使用构造函数来创建多个对象，可以将构造函数声明为私有的，这样客户端程序就不可以使用它来创建任何对象。
    
  
  
• 单例模式的问题
  
  
  
  • 如果声明构造函数为私有类型，那么没有客户端程序可以使用它来创建任何对象，因此它对客户端程序是无用的。
    
  
  

六、总结

单例模式优点

• 提供了对唯一实例的受控访问
  
• 可以节约系统资源，提高系统的性能
  
• 允许可变数目的实例（多例类）
  

单例模式缺点

• 扩展困难（缺少抽象层）
  
• 单例类的职责过重。单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中
  
• 由于自动垃圾回收机制，可能会导致共享的单例对象的状态丢失
  

使用情形

• 系统只需要一个实例对象，或者因为资源消耗太大而只允许创建一个对象
  
• 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例
  

扩展

单例模式分类

饿汉式(Eager Singleton)：顾名思义，该模式在类被加载时就会实例化一个对象。

1. public class EagerSingleton {
2.     private static final EagerSingleton instance = new EagerSingleton();
3.     private EagerSingleton() { }
4.     public static EagerSingleton getInstance() {
5.         return instance;
6.     }
7. }

复制代码

懒汉式(Lazy Singlenton)：该模式只在你需要对象时才会生成单例对象(比如调用getInstance方法)

1. public class LazySingleton {
2. private static LazySingleton instance = null;
3. private LazySingleton() { }
5. public static LazySingleton getInstance() {
6.         if (instance == null) {
7.                 instance = new LazySingleton();
8.     }
9.         return instance;
10. }
11. }

复制代码

关于Synchronized 类型的方法

• Synchronized类型的方法限制每个执行此方法的线程必须在执行下一个线程之前完全执行;
  
• 通过这种方式，创建的对象在多个线程的情况下是唯一的;
  
• 也就是说，我们已经给Synchronized类型的对象添加了锁。当一个线程执行此方法时，其他方法无法接管。其他线程应该等待.
  
• 只有在当前线程执行完该方法后，另一个线程才能开始执行该方法
  

锁方法：

1. public class LazySingleton {
2. private static LazySingleton instance = null;
3. private LazySingleton() { }
4. synchronized public static LazySingleton getInstance() {
5. if (instance == null) {
6. instance = new LazySingleton();
7.         }
8. return instance;
9. }
10. }

复制代码

锁代码段

1. public static LazySingleton getInstance() {
2.     if (instance == null) {
3.         synchronized (LazySingleton.class) {
4.             instance = new LazySingleton();
5.         }
6.     }
7.     return instance;
8. }

复制代码

懒汉式与饿汉式比较

懒汉式饿汉式实例化外部调用时类加载时线程安全不安全安全执行效率较低较高内存不浪费浪费单例模式实现多例

使用单例模式的思想可以实现多例模式，从而确保系统中某个类的对象只能存在有限个

单例类

1. //单例模式实现多例,实现3个
2. public class Multiton {
4.     private static ArrayList<Multiton> array = new ArrayList<>();
6.     private Multiton() {
7.     }
9.     public static Multiton getInstance(){
10.         if (array.size() < 3){
11.             System.out.println("创建实例成功");
12.             Multiton multiton = new Multiton();
13.             array.add(multiton);
14.             return multiton;
15.         }else {
16.             System.out.println("不再创建更多实例");
17.             return array.get(new Random().nextInt(array.size()));
18.         }
19.     }
21.     public int random() {
22.         int rand = (int) (Math.random()*3);
23.         return rand;
24.     }
27. }

复制代码

客户测试类

1. public class Client {
3.     public static void main(String[] args) {
4.         Multiton m1 = Multiton.getInstance();
5.         Multiton m2 = Multiton.getInstance();
6.         Multiton m3 = Multiton.getInstance();
7.         Multiton m4 = Multiton.getInstance();
8.         System.out.println("m1=m2"+(m1 == m2));
9.         System.out.println("m2=m3"+(m2 == m3));
10.         System.out.println("m3=m4"+(m3 == m4));
11.     }
13. }

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！