Java中单例模式的使用

小鱼儿 2022-07-16 10:18 204阅读 0赞

## 什么是单例模式 ##

单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

--------------------

## 单例模式的实例 ##

Java中案例模式的构建方法有两种，一种是懒汉模式，一种是饿汉模式。

*  懒汉模式，指全局的单例模式在第一次被使用时构建；
 *  饿汉模式，只全局的单例模式在类装载时构建；

我们来分别看一下Java中单例模式的实例

### 饿汉模式的代码如下 ###

public class Singleton{
    
        private static final Singleton INSTANCE = new Singleton;
    
        // Private constructor suppresses
        private Singleton(){
    
        // default public constructor
        public static Singleton getInstance() {
            return INSTANCE;
        }
    }

可见饿汉模式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

### 懒汉模式的代码如下 ###

线程不安全：

public class Singleton {
        private static Singleton instance;
        private Singleton (){}
    
        public static Singleton getInstance() {
         if (instance == null) {
             instance = new Singleton();
         }
         return instance;
        }
    }

线程安全：

public class Singleton{ 
    
        private static final Singleton INSTANCE = null;
    
        // Private constructor suppresses
        // default public constructor
        private Singleton(){
        }
    
        //thread safe and performance promote 
        public Singleton getInstance(){
            if(INSTANCE == null){
                synchronized(Singleton.class){
    //when more than two threads run into the first null check same time, to avoid instanced more than one time, it needs to be checked again.
                    if(INSTANCE == null){ 
                         INSTANCE = new Singleton();
                      }
                }
            }
            return INSTANCE;
        }
    }

可见懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间

由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？

### 枚举 ###

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，在Java枚举类中有详细介绍枚举的线程安全问题和序列化问题，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏

public enum Singleton{
    
            INSTANCE;
            public void whateverMethod(){
            }
        }

### 双重检查加锁 ###

可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受很大的影响。那么什么是“双重检查加锁”机制呢？

所谓“双重检查加锁”机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

“双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

注意：在java1.4及以前版本中，很多JVM对于volatile关键字的实现的问题，会导致“双重检查加锁”的失败，因此“双重检查加锁”机制只只能用在java5及以上的版本。

public class Singleton {
        private volatile static Singleton instance = null;
        private Singleton(){}
        public static Singleton getInstance(){
            //先检查实例是否存在，如果不存在才进入下面的同步块
            if(instance == null){
                //同步块，线程安全的创建实例
                synchronized (Singleton.class) {
                    //再次检查实例是否存在，如果不存在才真正的创建实例
                    if(instance == null){
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

这种实现方式既可以实现线程安全地创建实例，而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。

根据上面的分析，常见的两种单例实现方式都存在小小的缺陷，那么有没有一种方案，既能实现延迟加载，又能实现线程安全呢？

### Lazy initialization holder class模式 ###

这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

### 内部级类的基本知识 ###

简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。

类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。

类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。

类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载。

### 多线程缺省同步锁的知识 ###

大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

1.由静态初始化器（在静态字段上或static\{\}块中的初始化器）初始化数据时

2.访问final字段时

3.在创建线程之前创建对象时

4.线程可以看见它将要处理的对象时

### 怎样既能实现延迟加载，又能实现线程安全 ###

要想很简单地实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。

如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不会创建对象实例，从而同时实现延迟加载和线程安全。

public class Singleton { 
    
        private Singleton(){}
        /** * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例 * 没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。 */
        private static class SingletonHolder{ 
            /** * 静态初始化器，由JVM来保证线程安全 */
            private static Singleton instance = new Singleton();
        }
    
        public static Singleton getInstance(){
            return SingletonHolder.instance;
        }
    }

--------------------

## 使用单例模式的意义 ##

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如网站首页页面缓存）。

避免对资源的多重占用（比如写文件操作）。