04.单例模式

04.单例模式

概念：

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

单例模式是Java中最简单的设计模式之一。这种设计模式属于创建型模式。

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

用途：

单例模式的两个特点：

• 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。（比如网站首页页面缓存）
• 避免对资源的多重占用。（比如写文件操作）

实现方式：

我们可以显示对象的产生，将对象的构造方法私有化，使外面的类不能通过引用来产生对象。同时为了保证类的可用性，就必须提供一个自己对象以及访问这个对象的静态方法。

六种实现方式：

1、饿汉式

所谓的饿汉式，就是希望用到的实例能够立即拿到，而不需要等待任何时间，所以使用static修饰，在类加载的时候就直接创建。这样就可以保证在第一次想要使用该对象时，他已经被初始化。

同时，由于该实例在类被加载的时候就创建出来了，所以也避免了线程安全问题。

public class HungryHanStyle {
    /**
     * 在内部直接实例化一个实例
     */
    private static HungryHanStyle instance = new HungryHanStyle();

    /**
     * 将构造方法私有化
     */
    private HungryHanStyle(){
    }

    /**
     * 对外提供获取实例的静态方法
     * @return
     */
    public static HungryHanStyle getInstance(){
        return instance;
    }
}

还有一种写法，可以把实例化的过程放到静态块里面。

public class HungryHanStyle2 {
    /**
     * 在内部直接实例化一个实例
     */
    private static HungryHanStyle2 instance;

    static {
        instance = new HungryHanStyle2();
    }

    /**
     * 将构造方法私有化
     */
    private HungryHanStyle2(){

    }

    /**
     * 对外提供获取实例的静态方法
     * @return
     */
    public static HungryHanStyle2 getInstance(){
        return instance;
    }
}

测试：

public class SingletonTest {
    @Test
    public void hungryHanTest(){
        final HungryHanStyle instance = HungryHanStyle.getInstance();
        final HungryHanStyle instance1 = HungryHanStyle.getInstance();
        System.out.println(instance == instance1);
    }
}

2、静态内部类式

public class StaticInnterClassSingleton {
    //在静态内部类中初始化实例对象
    private static class SingletonHolder{
        private static final StaticInnterClassSingleton INSTANCE = new StaticInnterClassSingleton();
    }

    private StaticInnterClassSingleton(){
        System.out.println("StaticInnterClassSingleton构造方法被调用了");
    }

    public static final StaticInnterClassSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }

}

测试方法：

public class HungryHanTest {
    @Test
    public void StaticInnterClassSingleton(){
        System.out.println("获取单例之前");
        final StaticInnterClassSingleton instance = StaticInnterClassSingleton.getInstance();
        System.out.println("获取单例之后");
    }
}

这种方式利用了类加载机制，保证了初始化INSTANCE时只有一个线程，但是它和饿汉式还是有区别的：饿汉式是只要Singleton类被加载，instance就会被加载 ，而静态内部类式，是可以使用懒加载的，Singleton类被加载了，instance不一定会被初始化。

适合的场景：

如果实例化instance很消耗资源，另外一方面，不希望在Singleton类加载时就实例化，因为不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候这种方式就比饿汉式更合理。

3、懒汉式

所谓的懒汉式，就是不会提前将实例创建出来，将类对自己的实例化延迟到第一次被引用的时候，就是在调用获取单例方法时，才判断自己是否存在单例，如果没有才创建。

public class LazyStyle {
    private static LazyStyle instance;

    private LazyStyle(){}

    private static LazyStyle getInstance(){
        if(instance == null){
            instance = new LazyStyle();
        }

        return instance;
    }
    
}

仔细观察，会发现上述的方法其实是线程不安全的，在多线程情况下，可能会有两个线程同时进入if里面，就会创建两个不同的对象。

4、线程安全的懒汉式

public class SynchronizedLazyStyle {
    private static SynchronizedLazyStyle instance;

    private SynchronizedLazyStyle(){}

    private static synchronized SynchronizedLazyStyle getInstance(){
        if(instance == null){
            instance = new SynchronizedLazyStyle();
        }
        return instance;
    }
}

只要给getInstance方法加上synchronized锁，可以解决线程安全问题，但是由于锁的粒度太大，也会导致效率很低，因为有99%以上的情况都不需要走if里面的语句。

5、双重校验锁

针对上述方式，如何降低锁的粒度，又能保证线程安全性，其实只要缩小锁的范围就可以了。

public class DoubleCheckMode {
    private static DoubleCheckMode singleton;

    private DoubleCheckMode(){}

    public static DoubleCheckMode getInstance(){
        if(singleton == null){
            synchronized (DoubleCheckMode.class){
                if(singleton == null){
                    singleton = new DoubleCheckMode();
                }
            }
        }
        return singleton;
    }
}

以上代码，看上去好像没有任何问题，实现了惰性初始化，解决了同步问题，还减少了锁的范围，提高了效率。但是，还没有考虑到Java内存模型JMM。

线程A发现变量没有被初始化，然后它获取锁开始变量的初始化。

由于JMM，编译器生成的代码运行在线程A执行变量的初始化之前，更新变量并将其指向部分初始化的对象。

线程B发现共享变量已经被初始化，并返回变量。由于线程B确信单例变量已经初始化，它没有获取锁。如果A完成初始化之前共享变量对B可见（这是由于A没有完成初始化或者因为一些初始化的值还没有同步给B使用的内存（缓存一致性）），程序很可能崩溃。

因此，我们就需要引入一个关键字volatile来修饰singleton ，可以确保所有线程看到变量的值都是一致的。

public class DoubleCheckVolatileMode {
    private static volatile DoubleCheckVolatileMode singleton;

    private DoubleCheckVolatileMode(){}

    public static DoubleCheckVolatileMode getInstance(){
        if(singleton == null){
            synchronized (DoubleCheckVolatileMode.class){
                if(singleton == null){
                    singleton = new DoubleCheckVolatileMode();
                }
            }
        }
        return singleton;
    }
}

6、枚举式

public enum EnumSingleton {
    INSTANCE;
    EnumSingleton(){
        
    }
    
}

这种方式是不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，在深度分析Java的枚举类型——枚举的线程安全性及序列化问题中有详细介绍枚举的线程安全问题和序列化问题。

7、单例与序列化

序列化可以破坏单例。要想防止序列化对单例的破坏，只要在Singleton类中定义readResolve就可以解决该问题：

public class DoubleCheckVolatileSerializableMode implements Serializable {
    private static volatile DoubleCheckVolatileSerializableMode singleton;

    private DoubleCheckVolatileSerializableMode() {
    }

    public static DoubleCheckVolatileSerializableMode getInstance() {
        if (singleton == null) {
            synchronized (DoubleCheckVolatileSerializableMode.class) {
                if (singleton == null) {
                    singleton = new DoubleCheckVolatileSerializableMode();
                }
            }
        }
        return singleton;
    }


    private Object readResolve() {
        return singleton;
    }
}

测试：

public class SingletonTest {
    @Test
    public void doubleCheckVolatileSerializableMode() throws IOException, ClassNotFoundException {
        final ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(DoubleCheckVolatileSerializableMode.getInstance());
        final File file = new File("tempFile");
        final ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        final DoubleCheckVolatileSerializableMode newInstance = (DoubleCheckVolatileSerializableMode)objectInputStream.readObject();
        System.out.println(newInstance == DoubleCheckVolatileSerializableMode.getInstance());
    }
}