创建型模式之单例模式(Java版)

最新推荐文章于 2023-07-10 18:12:59 发布

Amy.wang96

最新推荐文章于 2023-07-10 18:12:59 发布

阅读量636

点赞数

分类专栏： # Creational Patterns

本文链接：https://blog.csdn.net/qq_34896730/article/details/105962832

版权

Creational Patterns 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

设计模式概述及分类:https://blog.csdn.net/qq_34896730/article/details/105324092

面向对象设计原则：https://editor.csdn.net/md/?articleId=105352240

单例模式目录

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

1 单例模式概述

对于一个软件系统中的某些类而言，只有一个实例很重要，例如一个系统只能有一个窗口管理器或文件系统，一个系统只能有一个计时工具或ID(序号)生成器等。在Windows操作系统中就只能打开一个任务管理器窗口，如图1-1所示。如果不使用机制对窗口对象进行唯一话势必会弹出多个窗口。如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性(即一个类只能创建一个实例)非常重要。

图1-1 Windows任务管理器

如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个系统的全局变量可以确保对象随时都可以被访问，但不能防止创建多个对象。一个更好的解决办法是让类自身负责创建和保存它的唯一实例，并保证不能创建其他实例，它还提供一个访问该实例的方法，这就是单例模式的动机。

单例模式： 确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。
单例模式是一种对象创建型模式。单例模式有3个要点：一是某个类只有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

2 单例模式结构与实现

2.1 单例模式结构

单例模式是结构最简单的设计模式，它只包含一个类，即单例类。单例模式的结构图如图2-1所示。

图2-1 单例模式结构图

由图2-1可知，单例模式只包含一个单例角色，也就是Singleton。

对于Singleton(单例),在单例类的内部创建它的唯一实例，并通过静态方法getInstance()让客户端可以使用它的唯一实例；为了防止在外部对单例类实例化，将其构造函数的可见性设为private;在单例类内部定义了一个Singleton类型的静态对象作为外部共享访问的唯一实例。

2.2 单例模式实现

单例模式的目的是保证一个类有且仅有一个实例，并提供一个访问它的全局访问点。单例模式包含的角色只有一个，也就是单例类Singleton。单例类拥有一个私有构造函数确保用户无法通过new关键字直接实例化它。除此之外，在单例类中还包含一个静态私有成员变量与静态公有工厂方法，该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
通常，单例模式的实现代码如下：

public class Singleton{
   private static Singleton instance = null;//静态私有成员变量
   //私有构造函数
   private Singleton(){
   }
   //静态公有工厂方法，返回唯一实例
   public static Singleton getInstance(){
      if(instance == null){
           instance = new Singleton();
       }
       return instance;
   }
}

为了测试单例类所创建对象的唯一性，可以编写一下客户端测试代码：

public class Client{
   public static void main(String args[]){
     Singleton s1 = Singleton.getInstance();
     Singleton s2 = Singleton.getInstance();
     //判断两个对象是否相同
     if(s1 == s2){
         System.out.println("两个对象是相同实例.");
      }else{
         System.out.println("两个对象是不同实例.");
      }
   }
}

编译代码并运行，输出结果为：

两个对象是相同实例.

      这说明两次调用getInstance()时所获得的对象是同一实例对象，且无法在外部对Singleton进行实例化，因此确保系统中只有唯一的一个Singleton对象。
      在单例模式的实现过程中需要注意以下3点：
      (1) 单例类构造函数的可见性为private。
      (2) 提供一个类型为自身的静态私有成员变量。
      (3) 提供一个公有的静态工厂方法。

3 单例模式应用实例

      1. 实例说明
      某软件公司承接了一个服务器负载均衡(Load Balance)软件的开发工作，该软件运行在一台负载均衡服务器上，可以将并发访问和数据流量分发到服务器集群中的多台设备上进行并发处理，提高系统的整体处理能力，缩短响应时间。由于集群中的服务器需要动态删减，且客户端请求需要统一分发，因此需要确保负载均衡器的唯一性，只能有一个负载均衡器来负责服务器的关联和请求的分发，否则将会带来服务器状态的不一致以及请求分配冲突问题。如何确保负载均衡器的唯一性是该软件成功的关键。
      2. 实例类图
      通过分析，本实例的结构图如图3-1所示。

图3-1 服务器负载均衡器结构图

在图3-1中，将负载均衡器LoadBalancer设计为单例类，其中包含一个存储服务器信息的即可serverList,每次在serverList中随机选择一台服务器来相应客户端我的请求。

3. 实例代码
(1) LoadBalancer:负载均衡器类，充当单例角色，在真实环境下该类将非常复杂，包括大量初始化工作和业务方法，在此只列出部分与模式相关的核心代码。

public class LoadBalancer{
   //私有静态成员变量，存储唯一实例
   private static LoadBalancer instance = null;
   //服务器集合
   private List serverList=null;
   //私有构造函数
   private LoadBalancer(){
      serverList = new ArrayList();
   }
   //公有静态成员方法，返回唯一实例
   public static LoadBalancer getLoadBalacner(){
      if(instance == null){
           instance = new LoadBalancer();
       }
       return instance;
  }
  //增加服务器
  public void addServer(String server){
       serverList.add(server);
   }
   //删除服务器
   public void removeServer(String server){
       serverList.remove(server);
   }
   //使用Random类随机获取服务器
   public String getServer(){
       Random random = new Random();
       int i = random.nextInt(serverList.size());
       return (String)serverList.get(i);
    }
}

(2) Client: 客户测试类。

public class Client{
   public static void main(String args[]){
      //创建4个LoadBalancer对象
      LoadBalancer balancer1,balancer2,balancer3,balancer4;
      balancer1 = LoadBalancer.getLoadBalancer();
      balancer2 = LoadBalancer.getLoadBalancer();
      balancer3 = LoadBalancer.getLoadBalancer();
      balancer4 = LoadBalancer.getLoadBalancer();
      //判断服务器负载均衡器是否相同
      if(balancer1 == balancer2 == balancer3 == balancer4){
       System.out.println("服务器负载均衡器具有唯一性");
    }
    //增加服务器
    balancer1.addServer("Server 1");
    balancer1.addServer("Server 2");
    balancer1.addServer("Server 3");
    balancer1.addServer("Server 4");
    //模拟客户端请求的分发，如果结果输出为同一个server,可以将i适当放大，例如改为"i<100"
    for(int i=0; i<10;i++){
        String server = balancer1.getServer();
        System.out.println("分发请求至服务器："+server);
     }
   }
}

4. 运行结果及分析
编译运行程序，输出结果如下：

服务器负载均衡具有唯一性！
分发请求至服务器：Server 1
分发请求至服务器：Server 4
分发请求至服务器：Server 4
分发请求至服务器：Server 1
分发请求至服务器：Server 2
分发请求至服务器：Server 2
分发请求至服务器：Server 1
分发请求至服务器：Server 4
分发请求至服务器：Server 3
分发请求至服务器：Server 2

虽然创建了4个LoadBalancer对象，但是实际上是同一个对象，因此通过使用单例模式可以确保LoadBalancer对象的唯一性。

4 饿汉式单例与懒汉式单例

1. 饿汉式单例
饿汉式单例类(Eager Singleton)是实现起来最简单的单例类，饿汉式单例类结构图如图4-1所示。

图4-1 饿汉式单例类图

从图4-1中可以看出，由于在定义静态变量的时候实例化单例类，因此在类加载时单例对象就已经创建，代码如下：

public class EagerSingleton{
   private static final EagerSingleton instance = new EagerSingleton();
   private EagerSingleton(){}
   public static EagerSingleton getInstance(){
      return instance;
  }
}

      当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。
      2. 懒汉式单例类与双重检查锁定
      与饿汉式单例类相同的是，懒汉式单例类(Lazy Singleton)的构造函数也是私有的。与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时将自己实例化，在懒汉式单例类被加载时不会将自己实例化。懒汉式单例类的结构图如图4-2所示。

图4-2 懒汉式单例类图

从图4-2中可以看出，懒汉式单例在第一次调用getInstance()方法时实例化，在类加载时并不自行实例化，这种技术又称为延迟加载(Lazy Load)技术，即需要的时候再加载实例。为了避免多个线程同时调用getInstance()方法，可以使用关键字synchronized,代码如下：

public class LazySingleton{
   private static LazySingleton instance = null;
   public LazySingleton(){}
   //使用synchroized关键字对方法进行加锁，确保任意时刻只有一个线程可执行该方法
   synchronized public static LazySingleton getInstance(){
     if(instance == null){
          instance = new LazySingleton();
      }
      return instance;
  }
}

在上述懒汉式单例类中，在getInstance()方法前面增加了关键字synchronized进行线程锁定，以处理多个线程同时访问的问题。上述代码虽然解决了线程安全问题，但是每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中将会导致系统性能大大降低。因此可以继续对懒汉式单例进行改进，通过分析发现无须对整个getInstance()方法进行锁定，只需要对其中的代码"instance = new LazySingleton();"进行锁定即可。getInstance()方法可以进行如下改进：

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

问题貌似得以解决，事实并非如此。如果使用以上代码来实现单例类，还是会存在单例对象不唯一的情况，原因如下：
例如在某一瞬间线程A和线程B都在调用getInstance()方法，此时instance对象为null值，均能通过"instance == null"的判断。由于实现了synchronized加锁机制，线程A进入synchronized锁定的代码中执行实例创建代码，线程B处于排队等待状态，必须等待线程A执行完毕后才可以进入synchronized锁定的代码。但当A执行完毕时线程B并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象，违背了单例模式的设计思想，因此需要进一步改进，在synchronized中再进行一次"instance == null"判断，这种方式称为双重检查锁定(Double-Check Locking)。使用双重检查锁定实现的懒汉式单例类的完整代码如下：

public class LazySingleton{
   private volatile static LazySingleton instance = null;
   private LazySingleton(){}
   public static LazySingleton{}
   public static LazySingleton getInstance(){
    //第一重判断
    if(instance == null){
        //锁定代码块
        synchronized(LazySingtelon.class){
           //第二重判断
           if(instance == null){
              instance = new LazySingleton();//创建单例实例
            }
        }
     }
     return instance;
   }
}

      需要注意的是，如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量instance之前增加修饰符volatile，被volatile修饰的成员变量可以确保多个线程都能正确处理，且该代码只能在JDK1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统的运行效率降低，因此即使使用双重检查检索来实现单例模式也不是一种完美的实现方式。
      3. 饿汉式单例类与懒汉式单例类的比较
      饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多个线程同时访问的问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。
      懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的几率变得很大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响。
      4. 使用静态内部类实现单例模式
      饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存；懒汉式单例类线程安全控制繁琐，而且性能受影响。可见无论是饿汉式单例还是懒汉式单例都存在一些问题。为了克服这些问题，在Java语言中可以通过Initialization on Demand Holder(IoDH)技术来实现单例模式。
      在IoDH中，需要在单例中增加一个静态(static)内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用，实现代码如下：

public class Singleton{
   private Singleton(){}
   //静态内部类
   private static class HolderClass{
     private final static Singleton instance = new Singleton();
   }
   public static Singleton getInstance(){
      return HolderClass.instance;
   }
   public static void main(String args[]){
       Singleton s1,s2;
       s1 = Singleton.getInstance();
       s2 = Singleton.getInstance();
       System.out.println(s1 == s2);
    }
}

      编译运行上述代码，运行结果为true,即创建的单例对象s1和s2为同一对象。由于静态单例对象没有作为Singleton对象的成员变量直接实例化，因此类加载时不会实例化Singleton,第一次调用getInstance()时将加载内部类HolderClass,在该类内部定义了一个static 类型的变量instance,此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。
      通过使用IODH既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式；其缺点是与编程语言本身的特性相关，很多面向对象的语言并不支持IODH。
      5. 使用枚举实现单例模式
      最佳实践，实现简单，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次。

enum Singleton {
    INSTANCE;
    public static void main(String[] args) {
        Singleton s1=Singleton.INSTANCE;
        Singleton s2=Singleton.INSTANCE;
        System.out.println(s1==s2);
    }
}

5 单例模式优/缺点与适用环境

5.1 单例模式优点

      (1) 单例模式提供了对唯一实例的受控访问。因为单例模式封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
      (2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式五一可以提高系统性能。
      (3) 允许可变数目的实例。基于单例模式可以进行扩展，使用与控制单例对象相似的方法来获得指定个数的实例对象，既节省系统资源，又解决了由于单例对象共享过多有损性能的问题。(注：自行提供指定数目实例对象的类可称为多例类)。

5.2 单例模式缺点

      (1) 由于单例模式中没有抽象层，因此单例模式扩展有很大的困难。
      (2) 单例类的职责过重，在一定程度上违背了单一职责原则。因为单例类及提供了业务方法，又提供了创建对象的方法(工厂方法)，将对象的创建和对象本身的功能耦合在一起。
      (3) 现在很多面向对象语言的运行环境都提供了自动垃圾回收技术，因此如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

5.3 单例模式使用环境

(1) 系统只需要一个实例对象，例如系统要求提供一个唯一的序列号生成器或资源管理器，或者因为资源消耗太大而只允许创建一个对象。
(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

Amy.wang96

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
创建型模式之单例模式(Java版)

设计模式概述及分类:https://blog.csdn.net/qq_34896730/article/details/105324092面向对象设计原则：https://editor.csdn.net/md/?articleId=105352240单例模式1 单例模式概述      单例模式是结构最简单的设计模式，在它的核心结构中...
复制链接

扫一扫