设计模式-单例设计模式

概念

顾名思义,就是确保某一个类在任何情况下都绝对只有一个实例,而且自行实例化并向外部提供一个该实例的全局访问点。这个类被称为单例类
单例模式是一种对象创建型模式

应用场景

  • 系统中只需要一个实例对象,如windows系统的资源管理器。
  • 客户调用类的单个实例,只允许使用一个全局访问点,除了该访问点,不能通过其他方式来访问该实例。

具体应用

设计模式-单例设计模式
单例模式只有一个角色

  • Singleton(单例):单例类对外隐藏了构造方法,在其内部只生成一个实例,同时它对外提供了一个静态的getInstance()工厂方法,让用户可以访问其唯一实例;在单例类内部定义了一个Singleton类型的静态对象,作为外部共享的唯一实例。

代码实践

负载均衡器的实现,将并发访问与数据流量分发至服务器集群中的多台设备上,提高整个系统的处理能力,缩短响应时间。
由于集群中的服务器在运行过程中会动态删减,且客户端的需求需要统一分发,因此需要确保负载均衡器的唯一性。

饿汉式单例

在单例类首次加载时就创建实例。
设计模式-单例设计模式

class EagerLoadBalancer {     //私有静态成员变量,存储唯一实例     private static EagerLoadBalancer instance = new EagerLoadBalancer();     //服务器集合     private List serverList = null;      //私有构造函数     private EagerLoadBalancer() {         serverList = new ArrayList();     }      //公有静态成员方法,返回唯一实例     public static EagerLoadBalancer getLoadBalancer() {         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);     } } 

当类被加载时,静态变量instance会被初始化,此时类的私有构造函数会被调用,单例类的唯一实例将被创建。

优点

由于是在单例类首次加载时就已经创建了实例,不会存在多线程情况下,出现多个实例的情况。

缺点

由于是在单例类首次加载时就已经创建了实例,所以不管最后有没有使用这个实例,该实例都已经存在了,会比较浪费内存空间

懒汉式单例(简单版)

在初始化时不去创建实例,而是在第一次需要使用的时候创建实例。
设计模式-单例设计模式
由图可知,懒汉式单例在第一次调用getInstance方法时实例化,在类加载时并不自行实例化,这种技术又称为延迟加载。

public class LazyLoadBalancer {     //私有静态成员变量,存储唯一实例     private static LazyLoadBalancer instance = null;     //服务器集合     private List serverList = null;      //私有构造函数     private LazyLoadBalancer() {         serverList = new ArrayList();     }      //公有静态成员方法,返回唯一实例     public static LazyLoadBalancer getLoadBalancer() {         if(instance == null){             instance = new LazyLoadBalancer();         }         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);     } } 

这便是最基本的懒汉式单例,看起来似乎没有什么问题,实际上在多线程情况下,会出现多个实例的情况。
懒汉式单例 多线程测试

    public static void main(String[] args) {         Thread th1 = new Thread(new Runnable() {             @Override             public void run() {                 LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th2 = new Thread(new Runnable() {             @Override             public void run() {                 LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th3 = new Thread(new Runnable() {             @Override             public void run() {                 LazyLoadBalancer loadBalancer = LazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         th1.start();         th2.start();         th3.start();     } 

测试结果
设计模式-单例设计模式
可以看到出现了2个不同的实例

懒汉式单例(线程安全版)

简单版的懒汉式单例,有线程安全问题,在多线程情况下会出现多个实例,这违背了单例模式只有一个实例的规则,我们可以在简单版的基础上,在getInstance方法上加上public class SyncLazyLoadBalancer { //私有静态成员变量,存储唯一实例 private static SyncLazyLoadBalancer instance = null; //服务器集合 private List serverList = null; //私有构造函数 private SyncLazyLoadBalancer() { serverList = new ArrayList(); } //公有静态成员方法,返回唯一实例 public static synchronized SyncLazyLoadBalancer getLoadBalancer() { if(instance == null){ instance = new SyncLazyLoadBalancer(); } 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); } public static void main(String[] args) { Thread th1 = new Thread(new Runnable() { @Override public void run() { SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer(); System.out.println(loadBalancer); } }); Thread th2 = new Thread(new Runnable() { @Override public void run() { SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer(); System.out.println(loadBalancer); } }); Thread th3 = new Thread(new Runnable() { @Override public void run() { SyncLazyLoadBalancer loadBalancer = SyncLazyLoadBalancer.getLoadBalancer(); System.out.println(loadBalancer); } }); th1.start(); th2.start(); th3.start(); } }

懒汉式单例(性能优化版double check)

在线程安全版中,由于将synchronized关键字加在了整个方法上,导致锁的粒度太大,我们可以减小锁的粒度,将该关键字加载创建实例的代码上,以达到性能优化的目的。
但是这样线程安全的问题又出现了,因为加入在某一瞬间,线程A和线程B同时调用了该方法,此时,instance实例是为null的,所以2个线程均能进入创建实例的代码,但因为创建实例的代码是加了锁的,所以导致2个线程会排队进入创建实例的代码,线程A创建完实例后,线程B又创建了一个新实例。所以这个方式需要改进。
我们可以在synchronized中再次进行instance == null避免这种情况出现。这种方式称为双重检查锁定(double check)
这种方式虽然比较完美的解决了性能与线程安全问题,但是在Java虚拟机内部,指令重排序后 ,还是有可能线程不安全,所以我们需要给对象加上volatile关键字,被这个关键字修饰的变量,在各个线程中是可见的,各个线程都能立即知道它的修改情况。
参考代码:

package com.donkeyx.pattern.factory.singleton.lazySingleton;  import java.util.ArrayList; import java.util.List; import java.util.Random;  public class DcLazyLoadBalancer {     //私有静态成员变量,存储唯一实例     private volatile static DcLazyLoadBalancer instance = null;     //服务器集合     private List serverList = null;      //私有构造函数     private DcLazyLoadBalancer() {         serverList = new ArrayList();     }      //公有静态成员方法,返回唯一实例     public static DcLazyLoadBalancer getLoadBalancer() {         if(instance == null){             synchronized (DcLazyLoadBalancer.class){                 if(instance == null){                     instance = new DcLazyLoadBalancer();                 }             }         }         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);     }      public static void main(String[] args) {         Thread th1 = new Thread(new Runnable() {             @Override             public void run() {                 DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th2 = new Thread(new Runnable() {             @Override             public void run() {                 DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th3 = new Thread(new Runnable() {             @Override             public void run() {                 DcLazyLoadBalancer loadBalancer = DcLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         th1.start();         th2.start();         th3.start();     } }  

懒汉式单例(静态内部类版)

静态内部类是懒汉式单例的最优解,它利用了JVM的加载机制,在内部类调用时才进行对象初始化,并且没有使用synchronized关键字,没有线程安全和性能问题,但是有被反射攻击的危险
参考代码

package com.donkeyx.pattern.factory.singleton.lazySingleton;  import java.util.ArrayList; import java.util.List; import java.util.Random;  public class InnerLazyLoadBalancer {      /**      * 使用一个静态内部类对单例对象进行创建动作      */     private static class Holder{         private final static InnerLazyLoadBalancer instance = new InnerLazyLoadBalancer();     }      //服务器集合     private List serverList = null;      //私有构造函数     private InnerLazyLoadBalancer() {         serverList = new ArrayList();     }      //公有静态成员方法,返回唯一实例     public static InnerLazyLoadBalancer getLoadBalancer() {         return Holder.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);     }      public static void main(String[] args) {         Thread th1 = new Thread(new Runnable() {             @Override             public void run() {                 InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th2 = new Thread(new Runnable() {             @Override             public void run() {                 InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th3 = new Thread(new Runnable() {             @Override             public void run() {                 InnerLazyLoadBalancer loadBalancer = InnerLazyLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         th1.start();         th2.start();         th3.start();     } } 

枚举式单例

这是单例模式的最佳实现方法,它既没有线程安全问题与性能问题,也没有被反射攻击的危险。
因为Java虚拟机会保证枚举对象的唯一性,因此,每个枚举类型和定义的枚举变量在JVM中都是唯一存在的。
通过对枚举类进行反编译发现,其内部对象实际上实在静态代码块中直接被加载。这种方式与饿汉式一致,也就没有所谓的线程安全问题
枚举类型的对象在反序列化时,是通过类名和名称进行实例化的,这种类名+名称的方式必然只有一个对象,所以也避免了反序列化时破坏单例

参考代码

package com.donkeyx.pattern.factory.singleton.lazySingleton;  import cn.hutool.core.lang.Singleton;  import java.util.ArrayList; import java.util.List; import java.util.Random;  public class EnumLoadBalancer {     //创建枚举对象     public static enum LoadBalancerEnum{         SINGLETON;         private EnumLoadBalancer instance = null;          private LoadBalancerEnum(){             instance = new EnumLoadBalancer();         }         public EnumLoadBalancer getInstance(){             return instance;         }     }     //服务器集合     private List serverList = null;      //私有构造函数     private EnumLoadBalancer() {         serverList = new ArrayList();     }      //公有静态成员方法,返回唯一实例     public static EnumLoadBalancer getLoadBalancer() {         return LoadBalancerEnum.SINGLETON.getInstance();     }      //增加服务器     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);     }      public static void main(String[] args) {         Thread th1 = new Thread(new Runnable() {             @Override             public void run() {                 EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th2 = new Thread(new Runnable() {             @Override             public void run() {                 EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         Thread th3 = new Thread(new Runnable() {             @Override             public void run() {                 EnumLoadBalancer loadBalancer = EnumLoadBalancer.getLoadBalancer();                 System.out.println(loadBalancer);             }         });         th1.start();         th2.start();         th3.start();     } } 

优点

  • 单例模式提供了对唯一实例的受控访问,因为单例类封装了它的唯一实例,所以它可以严格控制用户怎么去访问
  • 由于在系统中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象,单例模式可以提高系统性能

缺点

  • 单例模式没有抽象层,因此单例类的扩展有很大的困难
  • 单例类职责过重,违背单一职责原则。它既充当了工厂角色,提供了工厂方法,又充当了产品角色,包含了一些业务方法,将产品创建和产品功能融合在了一起
  • 运行环境的问题,在Java 或者C#这种提供了垃圾回收机制的 环境中,如果创建的实例长时间不使用,系统会将其标记为垃圾,会自动回收该实例,下次利用时,又将重新实例化,这将导致共享的单例对象状态丢失。
版权声明:玥玥 发表于 2021-03-15 8:14:24。
转载请注明:设计模式-单例设计模式 | 女黑客导航