设计模式之一----单例模式

在一个系统里，对于某些对象，有且只能有一个，当我们有这样的需求的时候，就需要用到单例模式了。

单例模式分为懒汉模式和饿汉模式。我们使用代码来进行说明:

首先创建一个用到了饿汉模式的Singleton类在com.single下:

package com.single;
/*
 * 单例模式
 * 场合：保证有些对象有且只有一个
 * 类型：饿汉模式
 * */
public class Singleton {
    //1、将构造方法私有化 不允许外部直接创建对象
    private Singleton(){}
    
    //2、类的唯一实例 只要类创建 该实例就会被创建
    private static Singleton instance = new Singleton();
    
    //3、提供一个用于获取实例的方法
    public static Singleton getInstance(){
        return instance;//类一被创建 该实例就会被创建
    }
}

然后创建一个用到了懒汉模式的Singleton2在com.single下：

package com.single;

public class Singleton2 {
    //1、将构造方法私有化
    private Singleton2(){}
    //2、声明类的唯一实例
    private static Singleton2 instance;//类加载的时候没有生成这个实例 而是用户获取来才生成这个实例
    //3、提供一个用于获取实例的方法
    public static Singleton2 getInstance(){
        if(instance == null){//仅当第一次尝试获取实例的时候才生成实例
            instance = new Singleton2();
        }
        return instance;
    }
}

最后写一个测试类Test在com.single下:

package com.single;

public class Test {
    public static void main(String[] args) {
        //饿汉模式
        Singleton s1 = Singleton.getInstance();//获取实例
        Singleton s2 = Singleton.getInstance();//获取实例
        System.out.println(s1==s1);//true 同一个实例 无论获取多少次都是同一个对象
        
        //懒汉模式
        Singleton2 s3 = Singleton2.getInstance();
        Singleton2 s4 = Singleton2.getInstance();
        System.out.println(s3==s4);//true 也是同一个实例
        
        //懒汉模式与饿汉模式的区别：
        //饿汉模式加载类的速度比较慢，但是允许时获取对象速度比较快 线程安全 
        //懒汉模式加载类比较快 但是运行时获取对象的速度比较慢 线程不安全
    }
}

前面我们提到了懒汉模式是线程不安全的，所以我们能不能想办法做成线程安全的呢？ 来尝试一下：

package com.single;

public class Singleton2 {
    private static Object lock = new Object();//生成一把锁
    //1、将构造方法私有化
    private Singleton2(){}
    //2、声明类的唯一实例
    private static Singleton2 instance;//类加载的时候没有生成这个实例 而是用户获取来才生成这个实例
    //3、提供一个用于获取实例的方法
    public static Singleton2 getInstance(){
    synchronized(lock){//加上锁
        if(instance == null){//仅当第一次尝试获取实例的时候才生成实例
            instance = new Singleton2();
        }
    }
        return instance;
    }
}

这样做是不是仿佛没什么问题了，但是我们要知道实际上加锁是开销特别大的，除了第一次生命单例以外我们用不到每次都加锁，所以我们采用双重校验锁：

package com.singleton;

public class Singleton2 {
    private Singleton2(){};
    private static Singleton2 instance;
    private static Object lock = new Object();
    public static Singleton2 getInstance(){
        if(instance == null){//只有第一次创建实例才加锁
            synchronized(lock){//加锁实际上很浪费时间
                if(instance == null){
                    instance = new Singleton2();
                    System.out.println("创建成功");
                }
            }
        }
        return instance;
    }
    public void save(){
        System.out.println("保存成功");
    }
}

仿佛没什么问题了是吧，但是由于JVM指令重排优化特性的存在，导致初始化Singleton和将对象地址赋给instance字段的顺序可能是不确定的，在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。然而volatile关键字除了保障变量被多线程访问的安全性的同时，还可以禁止JVM重排优化，所以这个地方最好在instance前加上volatile关键字：

package com.singleton;

public class Singleton2 {
    private Singleton2(){};
    private static volatile Singleton2 instance;//懒汉模式 默认线程不安全 慢
    private static Object lock = new Object();
    public static Singleton2 getInstance(){
        if(instance == null){
            synchronized(lock){//加锁实际上很浪费时间
                if(instance == null){
                    instance = new Singleton2();
                    System.out.println("创建成功");
                }
            }
        }
        return instance;
    }
    public void save(){
        System.out.println("保存成功");
    }
}

然而现在在不需要继承这个单例对象对应的类的时候有一种最简单，也绝对线程安全的方式：单枚举，详情点击链接