第五式 单例模式

单例模式

什么是单例模式

　　单例模式：确保一个类只有一个实例，并提供一个全局访问点。

　　我们把某个类设计成自己管理的一个单独实例，同时也避免其他类再自行产生实例。同时提供该实例的全局访问点，当你需要实例时，向类查询，会返回单个实例。

如何实现

　　平时我们需要对象时，都是new一个出来。这次单例设计模式，通过new的方式，每次出来的对象都不是同一个了，不符合单例模式设计原则。new对象是通过

类自身的公开的构造方法，我们可以通过将构造方式私有不让别人调用，然后提供一个静态方法让需要的人来获取该实例对象。根据该实例对象创建时间，可以分为

懒汉式和饿汉式。

　　饿汉式：

//饿汉式
public class Single {
    private static Single single = new Single();
    private Single(){}
    public static Single getInstance(){
        return single;
    }
}

　　懒汉式：

//懒汉式
public class Single {
    private static Single single;
    private Single(){}
    public static Single getInstance(){
        if(single == null){
            single = new Single();
        }
        return single;
    }
}

　　利弊：饿汉式在程序运行时就创建好了单例对象，这个对象可能会一直用不上，但一开始就被创建了占用资源，造成浪费。懒汉式是有人要用到这个单例对象时才把它创建出来，达到了

资源利用的最合理化，但是他不是线程安全的。看下面的代码就知道了，私有的构造方法被调用了两次，也就是说没有实现输出单例。

public class Client {
    public static void main(String[] args){
        for(int i=0;i<2;i++){
            //创建两个线程，去获取单例
            new Thread(){
                public void run(){
                    Singleton.getInstance();
                }
            }.start();
        }
    }
}

class Singleton {
    private static Singleton singleton;
    private Singleton(){
        System.out.println("我被创建了！");
        try {
            //模拟复杂对象创建时，耗费的时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

运行结果：
我被创建了！
我被创建了！

　　如果我们将getInstance方法变成同步方法，就可以避免多线程问题。像下面这样

    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

 运行结果：
 我被创建了！

　　通过增加synchronized关键字到getInstance()方法中，我们迫使每个线程在进入这个方法之前，要先等别的线程离开该方法，这样就没有两个线程同时进入这个方法了。虽然同步解决了线程安全这个问题，但是同步会降低性能，这又是另外一个问题。实际上只有第一次执行getInstance()方法时，才真正需要同步，一旦实例被创建完毕之后，就不需要同步了。优化一下代码

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

运行结果：
我被创建了！

　　这方法叫做“双重检查加锁”，在getInstance()中减少使用同步。

　　静态内部类实现单例模式，可以兼顾线程安全和懒加载。

//这种方式，线程安全，调用效率高，并且实现了延迟加载
class Singleton {
    private static class SingletonClassInstance{
        private static final Singleton singleton = new Singleton();
    }
    private Singleton(){
        System.out.println("我被创建了！");
        try {
            //模拟复杂对象创建时，耗费的时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static Singleton getInstance(){
        return SingletonClassInstance.singleton;
    }
}

　　 运行结果：
 　　我被创建了！

 　　要点：外部类没有static属性，不会像饿汉式那样立即加载对象；只有调用getInstance才会加载静态内部类，而加载类是天然的线程安全的，singleton是static final类型，保证了内存中只有一个实例存在；兼备了并发高效调用和延迟加载的优势。

应用场景

　　1、Windows的Task Manager(任务管理器)就是典型的单例模式

　　2、网站的计数器也是单例，不然不好同步

　　3、应用程序的日志应用，一般都使用单例模式，因为共享的日志文件一直处于打卡状态，只能一个实例去操作，否则不好追加

　　4、Spring中，每个Bean默认就是单例，这样可以方便被Spring容器管理

　　5、spring MVC框架中，控制器对象也是单例