单例模式以及其实现方式(懒汉与饿汉)

首先贴上官网对单例的介绍：

单例模式（Singleton Pattern）
是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

介绍
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：
1、一个班级只有一个班主任。 2、Windows
是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

我的理解是：
单例就相当于银行的取款机，一个程序相当于一个银行部门，一个银行只有一个取款机，每位客户去银行基本上都要用取款机，所以取款机是必须要有的，但同时只能有一个人使用。所以叫做单例。对应文档里面的优点相当于 这个取款机是一直存在的，每个客户都可以进到银行来使用，减小了银行服务人员的开销（节省了内存，减少资源浪费），缺点当然也就对应着银行中取款机只能做对应的业务，并不是所有业务都可以处理（没有接口，不能体现java的多态）。

那么下面来谈谈单例的实现，网上查阅了很多关于单例的博客，我将我查询到的知识进行总结：
1、饿汉式(线程安全，调用效率高，但是不能延时加载)：
代码如下：

//饿汉模式:延迟加载，在第一次用的时候才创建出对象，存在线程安全问题。
public class Singleton {

    private static Singleton singleton= new Singleton();
    private Singleton(){

    }
    public static Singleton getInstance(){
        return singleton;
    }
}

饿汉模式是未雨绸缪，将所有事都准备好，在其他东西在调用的时候直接拿去，那银行的例子来比较，就是你去银行取款，只需要直接使用取款机就好，取款机已经将取款流程都准备好，你只需要按照流程进行取款即可，不会有任何不安全因素，
饿汉模式
2.懒汉式(线程安全，调用效率不高，但是能延时加载)：

public class SingletonDemo2 {
    //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
    private static SingletonDemo2 instance;
    //构造器私有化
    private SingletonDemo2(){}
    
    //方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance(){
        if(instance==null){
            instance=new SingletonDemo2();
        }
        return instance;
    }
}

懒汉顾名思义，就是懒得只有必须做才会去做，在java中就是对象new出来之后都不会生成有这个对象里面的变量，只有要使用这个变量的时候使用getInstance()进行生成这个变量然后对其进行操作。但是懒汉是线程不安全的，因为在调用getInstance()时，如果多线程下，突然有个进程插了进来，将SingletonDemo2 中的instance变成了null（多线程中，很常见），这时就相当于引用了两个地址，即不符合了单例的定义，所以是线程不安全的，所以用Double CheckLock实现单例可以有效避免线程不安全，但是还是可能会出问题，还不是完全安全的。

3.Double CheckLock实现单例：DCL也就是双重锁判断机制（线程不安全，调用效率高，延时加载。由于JVM底层模型原因，偶尔会出问题，不建议使用）：

public class SingletonDemo3{  
    private static SingletonDemo3 singleton;  
    private SingletonDemo3 (){}  
    public static SingletonDemo3 getSingleton() {  
    if (singleton == null) {  
    	//添加synchronized可以避免方法的阻塞。
        synchronized (SingletonDemo3.class) {  
            singleton = new Singleton();  
        }  
    }  
    return singleton;  
    }  
}

增加同步锁，看似没什么问题了，可以放心大胆运行了，但是却有一个严重的缺陷在于：如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null，所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。
所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:

public class SingletonDemo4{
	public static SingletonDemo4 singleton =null;
	public static SingletonDemo4 getsingle() {
		if(singleton==null) {
			synchronized(SingletonDemo4.class) {
				if(singleton==null) {
					singleton=new SingletonDemo4();//实例化
				}
			}
		}
		return singleton;
	}
}

当然，懒汉与饿汉属于单例的实现模式，懒汉饿汉都是单例，各有各的优缺点，
4.静态内部类实现模式（线程安全，调用效率高，可以延时加载）

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

枚举单例有序列化和线程安全的保证，只要几行代码就能实现是单例最好的的实现方式

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。