前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >单例模式 Java 简介 学习笔记 及多种实现方式

单例模式 Java 简介 学习笔记 及多种实现方式

原创
作者头像
大鹅
发布2020-06-24 11:47:35
9550
发布2020-06-24 11:47:35
举报
文章被收录于专栏:大鹅专栏:大数据到机器学习

toc

1. 单例模式简介

1.1 定义

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

1.2 为什么要用单例模式呢?

在我们的系统中,有一些对象其实我们只需要一个,比如说:线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上,这一类对象只能有一个实例,如果制造出多个实例就可能会导致一些问题的产生,比如:程序的行为异常、资源使用过量、或者不一致性的结果。

简单来说使用单例模式可以带来下面几个好处:

  1. 对于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常可观的一笔系统开销;
  2. 由于 new 操作的次数减少,因而对系统内存的使用频率也会降低,这将减轻 GC 压力,缩短 GC 停顿时间。

1.3 为什么不使用全局变量确保一个类只有一个实例呢?

我们知道全局变量分为静态变量和实例变量,静态变量也可以保证该类的实例只存在一个。

只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。

但是,如果说这个对象非常消耗资源,而且程序某次的执行中一直没用,这样就造成了资源的浪费。利用单例模式的话,我们就可以实现在需要使用时才创建对象,这样就避免了不必要的资源浪费。 不仅仅是因为这个原因,在程序中我们要尽量避免全局变量的使用,大量使用全局变量给程序的调试、维护等带来困难。

1.4 spring中的单例模式

Spring 中 bean 的默认作用域就是 singleton(单例)的。 除了 singleton 作用域,Spring 中 bean 还有下面几种作用域:

  • prototype : 每次请求都会创建一个新的 bean 实例。
  • request : 每一次HTTP请求都会产生一个新的bean,该bean仅在当前HTTP request内有效。
  • session : 每一次HTTP请求都会产生一个新的 bean,该bean仅在当前 HTTP session 内有效。
  • global-session: 全局session作用域,仅仅在基于portlet的web应用中才有意义,Spring5已经没有了。Portlet是能够生成语义代码(例如:HTML)片段的小型Java Web插件。它们基于portlet容器,可以像servlet一样处理HTTP请求。但是,与 servlet 不同,每个 portlet 都有不同的会话

2. 单例的模式的实现

通常单例模式在Java语言中,有两种构建方式:

  1. 饿汉方式。指全局的单例实例在类装载时构建
  2. 懒汉方式。指全局的单例实例在第一次被使用时构建。

不管是那种创建方式,它们通常都存在下面几点相似处:

单例类必须要有一个 private 访问级别的构造函数,只有这样,才能确保单例不会在系统中的其他代码内被实例化;

instance 成员变量和 uniqueInstance 方法必须是 static 的。

2.1 饿汉方式(线程安全)

代码语言:txt
复制
    public class Singleton {
       //在静态初始化器中创建单例实例,这段代码保证了线程安全
        private static Singleton uniqueInstance = new Singleton();
        //Singleton类只有一个构造方法并且是被private修饰的,所以用户无法通过new方法创建该对象实例
        private Singleton(){}
        public static Singleton getInstance(){
            return uniqueInstance;
        }
    }

所谓 “饿汉方式” 就是说JVM在加载这个类时就马上创建此唯一的单例实例,不管你用不用,先创建了再说,如果一直没有被使用,便浪费了空间,典型的空间换时间,每次调用的时候,就不需要再判断,节省了运行时间。

这种方式和名字很贴切,饥不择食,在类装载的时候就创建,不管你用不用,先创建了再说,如果一直没有被使用,便浪费了空间,典型的空间换时间,每次调用的时候,就不需要再判断,节省了运行时间。

Java Runtime就是使用这种方式,它的源代码如下:

代码语言:txt
复制
public class Runtime {    
    private static Runtime currentRuntime = new Runtime();    
    /**     
    * Returns the runtime object associated with the current Java application.     
    * Most of the methods of class <code>Runtime</code> are instance     
    * methods and must be invoked with respect to the current runtime object.     *     
    * @return  the <code>Runtime</code> object associated with the current    
    *          Java application.     */   
    
    public static Runtime getRuntime() {        
        return currentRuntime;    
    }    
    /** Don't let anyone else instantiate this class */   
    private Runtime() {}	//以下代码省略
}

2.2 懒汉式(非线程安全和synchronized关键字线程安全版本 )

代码语言:txt
复制
public class Singleton {  
      private static Singleton uniqueInstance;  
      private Singleton (){
      }   
      //没有加入synchronized关键字的版本是线程不安全的
      public static Singleton getInstance() {
          //判断当前单例是否已经存在,若存在则返回,不存在则再建立单例
	      if (uniqueInstance == null) {  
	          uniqueInstance = new Singleton();  
	      }  
	      return uniqueInstance;  
      }  
 }

所谓 “ 懒汉式” 就是说单例实例在第一次被使用时构建,而不是在JVM在加载这个类时就马上创建此唯一的单例实例。

「懒汉式」与「饿汉式」的最大区别就是将单例的初始化操作,延迟到需要的时候才进行,这样做在某些场合中有很大用处。比如某个单例用的次数不是很多,但是这个单例提供的功能又非常复杂,而且加载和初始化要消耗大量的资源,这个时候使用「懒汉式」就是非常不错的选择。

但是上面这种方式很明显是线程不安全的,如果多个线程同时访问getInstance()方法时就会出现问题。如果想要保证线程安全,一种比较常见的方式就是在getInstance() 方法前加上synchronized关键字,如下:

代码语言:txt
复制
  public static synchronized Singleton getInstance() {  
      if (instance == null) {  
          uniqueInstance = new Singleton();  
      }  
      return uniqueInstance;  
  }  

我们知道synchronized关键字偏重量级锁。虽然在JavaSE1.6之后synchronized关键字进行了主要包括:为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升。

Android中的 InputMethodManager 使用了这种方式,我们看看它的源码:

代码语言:txt
复制
public final class InputMethodManager {    
static InputMethodManager sInstance;         
    /**     
    * Retrieve the global InputMethodManager instance, creating it if it     
    * doesn't already exist.     
    * @hide     
    */    
    public static InputMethodManager getInstance() {
        synchronized (InputMethodManager.class) {
            if (sInstance == null) {
                IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
                IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
                sInstance = new InputMethodManager(service, Looper.getMainLooper());
            }
            return sInstance;        
        }    
    }
}

但是在程序中每次使用getInstance() 都要经过synchronized加锁这一层,这难免会增加getInstance()的方法的时间消费,而且还可能会发生阻塞。我们下面介绍到的 双重检查加锁版本 就是为了解决这个问题而存在的。

2.3 懒汉式(双重检查加锁版本)

利用双重检查加锁(double-checked locking),首先检查是否实例已经创建,如果尚未创建,“才”进行同步。这样以来,只有一次同步,这正是我们想要的效果。

代码语言:txt
复制
public class Singleton {
	//volatile保证,当uniqueInstance变量被初始化成Singleton实例时,多个线程可以正确处理uniqueInstance变量
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public static Singleton getInstance() {
       //检查实例,如果不存在,就进入同步代码块
        if (uniqueInstance == null) {
            //只有第一次才彻底执行这里的代码
            synchronized(Singleton.class) {
               //进入同步代码块后,再检查一次,如果仍是null,才创建实例
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

很明显,这种方式相比于使用synchronized关键字的方法,可以大大减少getInstance() 的时间消费。

注意: 双重检查加锁版本不适用于1.4及更早版本的Java。

1.4及更早版本的Java中,许多JVM对于volatile关键字的实现会导致双重检查加锁的失效。

2.4 懒汉式(登记式/静态内部类方式)

静态内部实现的单例是懒加载的且线程安全。

只有通过显式调用 getInstance 方法时,才会显式装载 SingletonHolder 类,从而实例化 instance(只有第一次使用这个单例的实例的时候才加载,同时不会有线程安全问题)。

代码语言:txt
复制
public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}   

2.5 饿汉式(枚举方式)

这种实现方式还没有被广泛采用,但这是实现单例模式的最佳方法。 它更简洁,自动支持序列化机制,绝对防止多次实例化 (如果单例类实现了Serializable接口,默认情况下每次反序列化总会创建一个新的实例对象,关于单例与序列化的问题可以查看这一篇文章《单例与序列化的那些事儿》),同时这种方式也是《Effective Java 》以及《Java与模式》的作者推荐的方式。

代码语言:txt
复制
public enum Singleton {
	 //定义一个枚举的元素,它就是 Singleton 的一个实例
    INSTANCE;  
    
public void doSomeThing() {  
     System.out.println("枚举方法实现单例");
}  

使用方法:

代码语言:txt
复制
public class ESTest {

    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        singleton.doSomeThing();//output:枚举方法实现单例

    }
}

《Effective Java 中文版 第二版》

这种方法在功能上与公有域方法相近,但是它更加简洁,无偿提供了序列化机制,绝对防止多次实例化,即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用,但是单元素的枚举类型已经成为实现Singleton的最佳方法。

《Java与模式》

使用枚举来实现单实例控制会更加简洁,而且无偿地提供了序列化机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 1. 单例模式简介
    • 1.1 定义
      • 1.2 为什么要用单例模式呢?
        • 1.3 为什么不使用全局变量确保一个类只有一个实例呢?
          • 1.4 spring中的单例模式
          • 2. 单例的模式的实现
            • 2.1 饿汉方式(线程安全)
              • 2.2 懒汉式(非线程安全和synchronized关键字线程安全版本 )
                • 2.3 懒汉式(双重检查加锁版本)
                  • 2.4 懒汉式(登记式/静态内部类方式)
                    • 2.5 饿汉式(枚举方式)
                    相关产品与服务
                    容器服务
                    腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
                    领券
                    问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档