单例模式

定义

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

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以创建，并且它可以提供一个访问该实例的方法。

UML图

方式一：单线程下的单例

/**
 * Created by callmeDevil on 2019/8/17.
 */
public class Singleton {

    private static Singleton instance;

    private Singleton(){} //构造方法私有，防止外界创建实例

    // 获得本类实例的唯一全局访问点
    public static Singleton getInstance(){
        if (instance == null) {
            //若实例不存在，则创建一个新实例，否则直接返回已有实例
            instance = new Singleton();
        }
        return instance;
    }

}

测试

public class Test {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        if (s1 == s2) {
            System.out.println("两个对象是相同的实例");
        }
    }
}

测试结果

两个对象是相同的实例

在没有并发问题的情况下，这种方式也是使用比较多的。但缺点也很明显，多线程下根本没法用。

方式二：多线程下的单例

/**
 * Created by callmeDevil on 2019/8/17.
 */
public class SingletonOnLock {

    private static SingletonOnLock instance;

    private SingletonOnLock(){}

    public static SingletonOnLock getInstance(){
        // 同步代码块，只有一个线程能进入，其他阻塞
        synchronized (SingletonOnLock.class){
            if(instance == null){
                instance = new SingletonOnLock();
            }
        }
        return instance;
    }

}

存在问题

当存在对象实例时，完全不用担心并发时导致堆中创建多个实例，但每次调用 getInstance() 方法时都被加锁，是会影响性能的，因此这个类可以继续改良。

方式三：双重锁定（DCL）

/**
 * Created by callmeDevil on 2019/8/17.
 */
public class SingletonOnDoubleCheckLock {

    private static SingletonOnDoubleCheckLock instance;

    private SingletonOnDoubleCheckLock(){}

    public static SingletonOnDoubleCheckLock getInstance(){
        // 先判断实例是否存在，不存在再考虑并发问题
        if (instance == null) {
            synchronized (SingletonOnDoubleCheckLock.class){
                if(instance == null){
                    instance = new SingletonOnDoubleCheckLock();
                }
            }
        }
        return instance;
    }

}

两次判断实例是否存在的原因

当实例存在时，就直接返回，这是没有问题的。当实例为空并且有两个线程调用 getInstance() 方法时，它们都可以通过第一重 instace == null 的判断，然后由于 synchronized 机制，只有一个线程可以进入，另一个阻塞，必须要在同步代码块中的线程出来后，另一个线程才会进入。而此时如果没有第二重的判断，那第二个线程仍然会创建实例，这就达不到单例的目的了。

但这种方式是最让人“诟病”的一种不推荐方式，技巧看上去很好，但实际上同样影响性能。

方式四：静态初始化

/**
 * 该类声明为final ，阻止派生，因为派生可能会增加实例
 * Created by callmeDevil on 2019/8/17.
 */
public final class SingletonStatic {

    // 第一次引用类的任何成员时就创建好实例，同时没有并发问题
    private static final SingletonStatic instance = new SingletonStatic();

    private SingletonStatic(){}

    public static SingletonStatic getInstance(){
        return instance;
    }

}

JVM第一次加载类的时候就已经创建好了实例，如果接下来的很长时间都没有用到的话，占用的内存相当于被浪费了，也不是最让人推荐的一种方式。当然现在的服务器容量也越来越大，单单一个实例的内存也并不是任何情况都要考虑节省。除非追求极致。。

总结

静态初始化的方式是自己被加载时就已经将自己实例化，因此也被称为“饿汉式”。
其他方式是要在第一次被引用时，才会将自己实例化，所以被称为“懒汉式”。
其实单例模式还有很多种实现方式，下面再提一种《大话设计模式》中未提到的实现：静态内部类。 这是楼主在《Java并发编程实战》中看到的，也是最为推荐的一种。

扩展

方式五：静态内部类

/**
 * Created by callmeDevil on 2019/8/17.
 */
public class SingletonStaticClass {

    private SingletonStaticClass() {}

    public SingletonStaticClass getInstande() {
        return InterClass.instance;
    }

    // 静态内部类，没有并发问题
    private static final class InterClass {
        public static SingletonStaticClass instance = new SingletonStaticClass();
    }

}

大话设计模式笔记（十八）の单例模式

单例模式

定义

UML图

方式一：单线程下的单例

测试

测试结果

方式二：多线程下的单例

存在问题

方式三：双重锁定（DCL）

两次判断实例是否存在的原因

方式四：静态初始化

总结

扩展

方式五：静态内部类

推荐原因

大话设计模式笔记（十八）の单例模式

单例模式

定义

UML图

方式一：单线程下的单例

测试

测试结果

方式二：多线程下的单例

存在问题

方式三：双重锁定（DCL）

两次判断实例是否存在的原因

方式四：静态初始化

总结

扩展

方式五：静态内部类

推荐原因

相关推荐