10分钟快速学习Java单例模式

概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

优缺点

优点

1. 实例控制。单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
2. 灵活性。因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点

1. 开销。虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

2. 开发过程中可能混淆。使用打单例对象时，无法new一个对象，在实际应用开发中，如果不清楚，开发人员会发现无法实例化此类

3. 对象生存期。不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

快速实现单例模式

饿汉模式

简单来说就是是将类的构造器私有化，那么就不能在外部调用 new 创建实例了。

其次，通过调用静态方法获取实例。一般情况下这个模式就够了

public class MySingle {
    private MySingle() {}

    private static MySingle instance = new MySingle();

    public static MySingle getInstance() {
        return instance;
    }
}

这种模式用起来方便，但是我们会发现里面的一个弊端就是，无论你有没有用到MySingle的对象，它都会被实例化。；在实际开发中，当多个地方去访问它时，无论有没有用到它的对象，MySingle都会被实例化一次，毫无疑问这样做十分占用空间资源。

懒汉模式及其衍生问题

为解决“饿汉模式”带来得资源过多占用的问题，我们可以使用“懒汉模式”，即让MySingle只有在用到时候才去加载它

设计思路及代码

public class MySingle {

    private MySingle() {
    }

    private static  MySingle mySingle=null;
   
    public static MySingle getInstance(){
        if(mySingle==null){ 
            mySingle=new MySingle();
        }
        return mySingle;
    }
}

但是这种做法只能在单线程种使用，如果使用在多线程，却可能会实例化出多个对象。也就是说，它的线程并不是安全的。为了解决这个问题，需要对 getInstance 这个方法加锁，可以使用synchronized关键字:

设计思路及代码

public class MySingle {

    private MySingle() {
    }

    private static  MySingle mySingle=null;

   	//为getInstance加锁，确保多个线程调用时，防止方法串行
	//方法串行就是：比如有一个线程正在访问到判断mySingle是不是为空这里
	//另一个线程已经走到mySingle=new MySingle（）这里

    public synchronized static MySingle getInstance(){
        if(mySingle==null){ 
            mySingle=new MySingle();
        }
        return mySingle;
    }
}

上述加锁的方式，可以保证正确实例化对象。但是，因为在方法上加了锁，使得获取单例对象的效率过低。因为每次只有一个线程可以去调用它，其他的线程进入等待。只有当前线程访问完毕时，其他线程才可以竞争唯一的名额去访问这个方法，所以效率十分低下。这时候，需要兼顾线程安全和效率，就出现了双重检查锁的概念:

设计模式及代码如下：

public class MySingle {
	//私有化构造函数
    private MySingle() {
    }
	//volatile确保对象都是最新的
    private static volatile MySingle mySingle=null;
    //双重验锁
    public static MySingle getInstance(){
		//第一重
        if(mySingle==null){
			//synchronized锁住当前对象
            synchronized (MySingle.class){
				//第二重
                if(mySingle==null){
                    mySingle=new MySingle();
                }
            }
        }
        return mySingle;
    }
}

其中:

synchronized 块尽量缩小了锁定的范围，提高效率

volatile 是为防止编译器指令重排而导致双重检查锁失效

另外:

指令重排本是为了优化代码执行效率而存在的，虽然在单线程中效果拔群，但是在多线程中却能带来麻烦。volatile 可以要求编译器不要做指令重排。

小结：
双重验锁的方式是一种兼顾了多线程的安全和效率的方式，也是面试中一个比较常见的题目，也是单例模式中较为保险的做法，值得大家注意和使用。

静态内部类方式

相对于上面的实现方式来说，这是一种十分优秀的实现模式，在很多地方推荐使用。

设计思路和代码

class MySingle{
    private MySingle(){}
	//静态内部类
    private static class newInstance{
        static final MySingle MYSINGLE =new MySingle();
    }

    public static MySingle getInstance(){
        return newInstance.MYSINGLE;
    }

}

这种方法充分利用了静态内部类的特性，在它的里面实例化MySingle。使用静态内部类里面的成员，如：变量、方法等 ，它们被调用时，静态内部类才会被加载。而且只会加载一次。这样无论多少线程通过getInstance（）公共方法调用MySingle时都是调用了同一个对象，只被实例化了一次，而且在静态代码块里面也不存在线程安全的问题。

ENUM方式(枚举)

ENUM 应该是最简单，也是最好的一种实现单例模式的方式。

它充分利用了 JVM 的特性，既保证了线程安全，又保证了延迟加载。

设计思路及代码

enum MySingle {
    INSTANCE;

    public void sayHello () {
        System.out.println("hello");
    }
}

public class Main {
    public static void main (String... args) {
        MySingle mySingle = MySingle.INSTANCE;  // 获取实例
        mySingle.sayHello();            // 调用方法
    }
}