[设计模式]2.单例模式

一、单例模式简介

单例模式(Singleton)是一种常用的设计模式,其定义是单例对象的类只能允许一个实例存在。该类创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

二、单例模式的基本实现思路

单例模式要求类能够返回同一个对象的实例，和获取该对象的方法(必须是静态方法，通常使用getInstance来命名)。

单例实现的主要步骤

1.私有的(private)构造方法，让其他代码无法通过调用该类的构造方法来实例化这个对象，只能通过提供的静态方法来得到该类的唯一实例。
2.调用提供的静态方法时，该类的对象的引用不为空时返回该实例对象的引用，否则实例化再返回该类的引用。

三、使用单例模式的注意事项

单例模式在多线程的应用场合中使用需要小心。因为当多个线程同时调用创建方法是，实例还没被创建。则会同时创建一个实例。这样会导致多个实例创建出来，这样就违反了实例唯一的原则。为了解决这个问题需要为已经实例化的变量提供一个互斥锁，但是这样做会降低效率。

三、单例的具体实现

1.饿汉式(静态常量)[可用]

public class StaticConstantSingleton {

    private static final StaticConstantSingleton INSTANCE = new StaticConstantSingleton();

    private StaticConstantSingleton() {
    }

    public static StaticConstantSingleton getInstance() {
        return INSTANCE;
    }
}

优点:

写法简单，在类加载时就完成了对象的实例化，避免了下城同步问题。

缺点:

因为在类已加载时就创建了对象，并没有在需要的时候才创建，导致资源浪费。

2.饿汉式(静态代码块)[可用]

public class StaticBlockSingleton {

    private static StaticBlockSingleton instance;

    static {
        instance = new StaticBlockSingleton();
    }

    private StaticBlockSingleton() {
    }

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

与饿汉式(静态常量)方式类似,只不过把类的实例化过程发在了静态代码块中，也是在类加载的手就执行静态代码块中的代码，创建类的实例。优缺点类似。

3.懒汉式(线程安全,同步方法)[不推荐使用]

public class SynchronizedMetodSingleton {

    private static SynchronizedMetodSingleton instance;

    private SynchronizedMetodSingleton() {
    }

    public static synchronized SynchronizedMetodSingleton getInstance(){
        if (null == instance) {
            instance = new SynchronizedMetodSingleton();
        }
        return instance;
    }
}

在创建实例的方法上做了线程同步。

缺点:

在每个线程要获得该类的实例时,执行getInstance方法都进行了同步。
但是其实这个方法只需要进行一次实例化，后面想要获得该类的实例，直接return就行。方法进行同步效率太低。

4.双重检查

public class DoubleCheckSingleton {

    private volatile static DoubleCheckSingleton INSTANCE;

    private DoubleCheckSingleton() {
    }

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

实现了线程安全和lazy loding。效率较高

5.内部静态类[推荐用]

public class StaticInnerClassSingleton {

    private StaticInnerClassSingleton() {
    }

    private static class SingletonInstance{
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

只有在调用getInstance方法时调用了SingletonInstance类时,对象才会实例化。类的静态熟悉只会在第一次类加载的时候初始化。避免了线程不安全,延迟加载，效率高。

6.枚举[推荐用]

public enum EnumSigleton {

    INSTANCE;

    private EnumSigleton(){

    }
}

枚举是在JDK1.5后引入的，在现在大家普遍使用JDK1.7和JDK1.8来开发的，推荐使用枚举来实现单例模式。不仅可以避免线程同步问题，而且还能防止反序列化重新创建新的对象。

示例代码:https://github.com/code-wangdi/Design-Patterns 中的Singleton-Pattern