Java单例模式及开发应用场景

一、Java单例模式是什么？

所谓单例，指的就是单实例，有且仅有一个类实例，这个单例不应该由人来控制，而应该由代码来限制，强制单例。

二、为什么要用单例模式？

单例有其独有的使用场景，一般是对于那些业务逻辑上限定不能多例只能单例的情况，例如：类似于计数器之类的存在，一般都需要使用一个实例来进行记录，若多例计数则会不准确。

三、如何实现Java单例模式？

1、饱汉模式(懒汉模式)

// 饱汉
// UnThreadSafe
public class Singleton {
  private static Singleton singleton = null;
  private Singleton() {
  }
  public static Singleton getInstance() {
    if (singleton == null) {
      singleton = new Singleton();
    }
    return singleton;
  }
}

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。

缺点：非线程安全。

2、饱汉模式(懒汉模式)--线程安全

public class Singleton {

    /**
     * 定义一个变量来存储创建好的类实例
     */

    private static Singleton uniqueInstance = null;

    /**
     * 私有化构造方法，好在内部控制创建实例的数目
     */

    private Singleton(){
    }

    /**
     * 定义一个方法来为客户端提供类实例
     * @return 一个Singleton的实例
     */

    public static synchronized Singleton getInstance(){

        //判断存储实例的变量是否有值
        if(uniqueInstance == null){
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            uniqueInstance = new Singleton();
        }

        //如果有值，那就直接使用
        return uniqueInstance;
    }

    /**
     * 示意方法，单例可以有自己的操作
     */

    public void singletonOperation(){

//功能处理

    }

    /**
     * 示意属性，单例可以有自己的属性
     */

    private String singletonData;

    /**
     * 示意方法，让外部通过这些方法来访问属性的值
     * @return 属性的值
     */

    public String getSingletonData(){

        return singletonData;

    }

}

优点：同上，但加锁了。

 缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。

3、饱汉模式(懒汉模式)--双重加锁检查DCL（Double Check Lock）

public class Singleton {

    /**
     * 对保存实例的变量添加volatile的修饰
     */

    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 关键字修饰，其保证初始化完全。

4、饿汉模式，一开始就申请好，浪费了点资源，但其线程安全。

public class Singleton {

//4：定义一个静态变量来存储创建好的类实例

//直接在这里创建类实例，只会创建一次

    private static Singleton instance = new Singleton();

//1：私有化构造方法，好在内部控制创建实例的数目

    private Singleton(){

    }

//2：定义一个方法来为客户端提供类实例

//3：这个方法需要定义成类方法，也就是要加static

//这个方法里面就不需要控制代码了

    public static Singleton getInstance(){

//5：直接使用已经创建好的实例

        return instance;

    }

}

优点：饿汉模式天生是线程安全的，使用时没有延迟。

 缺点：启动时即创建实例，启动慢，有可能造成资源浪费。

5、Holder模式，改成内部类，由JVM保证线程安全性。

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

 优点：将懒加载和线程安全完美结合的一种方式（无锁）。（推荐）