一、单例模式介绍
单例模式是应用最广的模式，在我们创建一个对象时为避免消耗过多的资源，我们便采用单例模式。
单例模式的定义是它应保证一个类仅有一个实例，同时这个类还必须提供访问该类的全局访问点。
实现单例模式有以下几个关键点：
1、其构造函数不对外开放，一般为private；
2、通过一个静态方法或者枚举返回单例对象；
3、确保单例对象有且只有一个，尤其是多线程的场景；
4、确保单例类对象的反序列化时不会重新创建对象；
二、单例模式的六种实现方式：
1、懒汉式（线程不安全）

package com.ceshi.single;
/*
 * 懒汉模式，线程不安全
 */
public class SingletonA {

    private static SingletonA instanceA = null;

    private SingletonA() {

    }

    public static SingletonA getInstanceA() {
        if (instanceA == null) {
            return new SingletonA();
        } else {
            return instanceA;
        }
    }
}

懒汉式（线程不安全）的单例模式分为三个部分：私有的构造方法，私有的全局静态变量，公有的静态方法。

其中起到重要作用的是静态修饰符static关键字，我们知道在程序中，任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，因此也就保证了单例类的实例一旦创建，便不会被系统回收，除非手动设置为null。

2、懒汉式（线程安全）

package com.ceshi.single;

/*
 * 懒汉模式、线程安全
 */
public class SingletonB {

    private static SingletonB instanceB=null;
    private SingletonB(){

    }

    public static synchronized SingletonB getInstanceB(){
        if (instanceB==null) {
            return new SingletonB();

        }else {
            return instanceB;
        }
    }
}

同步的意思是当两个并发线程访问同一个类中的这个synchronized同步方法时， 一个时间内只能有一个线程得到执行，另一个线程必须等待当前线程执行完才能执行，因此同步方法使得线程安全，保证了单例只有唯一个实例。

但是它的缺点在于每次调用getInstance（）都进行同步，造成了不必要的同步开销。这种模式一般不建议使用。

3、恶汉模式（线程安全）

package com.ceshi.single;

/*
 * 恶汉模式
 */
public class SingletonC {

    //创建一个静态的对象供系统使用，所以天生就是安全的。
    private static SingletonC instanceC=new SingletonC();

    private SingletonC(){

    }

    public static SingletonC getInstanceC(){
        return instanceC;
    }
}

4、DCL双重校验模式：

package com.ceshi.single;

/*
 * DCL双检校验模式
 */
public class SingletonD {

    private static SingletonD instanceD=null;

    private SingletonD(){

    }

    public static SingletonD getInstanceD(){
        if (instanceD==null) {
            synchronized (SingletonD.class) {
                if (instanceD==null) {
                    return new SingletonD();
                }
            }
        }
        return instanceD;
    }
}

这种模式的亮点在于getInstance（）方法上，其中对singleton 进行了两次判断是否空，第一层判断是为了避免不必要的同步，第二层的判断是为了在null的情况下才创建实例。具体我们来分析一下：

假设线程A执行到了singleton = new Singleton(); 语句，这里看起来是一句代码，但是它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致会做三件事情：
（a）给Singleton的实例分配内存
（b）调用Singleton（）的构造函数，初始化成员字段；
（c）将singleton对象指向分配的内存空间（即singleton不为空了）；

但是由于Java编译器允许处理器乱序执行，以及在jdk1.5之前，JMM（Java Memory Model：java内存模型）中Cache、寄存器、到主内存的回写顺序规定，上面的步骤b 步骤c的执行顺序是不保证了。也就是说执行顺序可能是a-b-c，也可能是a-c-b,如果是后者的指向顺序，并且恰恰在c执行完毕，b尚未执行时，被切换到线程B中，这时候因为singleton在线程A中执行了步骤c了，已经非空了，所以，线程B直接就取走了singleton，再使用时就会出错。这就是DCL失效问题。
但是在JDK1.5之后，官方给出了volatile关键字，将singleton定义的代码改成：

private volatile static Singleton singleton;  //使用volatile 关键字

5、静态内部类：

package com.ceshi.single;

public class SingletonE {
    /*
     * 内部类实现单利模式
     * 延迟加载，减少内存开销
     * 
     */
    private static class SingletonHolder{
        private static SingletonE instancE=new SingletonE();
    }

    /*
     * 私有构造
     */
    private SingletonE(){

    }
    public static SingletonE getInstanceE(){
        return SingletonHolder.instancE;
    }
}

优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗。

6、枚举方法：

package com.ceshi.single;

import java.io.Serializable;

/*
 * 枚举实现
 */
public enum SingletonF implements Serializable {

    /**
     * 1.从Java1.5开始支持; 2.无偿提供序列化机制; 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候;
     */
    INSTANCE;

    private String others;

    public String getOthers() {
        return others;
    }

    public void setOthers(String others) {
        this.others = others;
    }

    /*
     * 调用 SingletonF singleton = SingletonF.INSTANCE;
     */
}

枚举单例模式最大的优点就是写法简单，枚举在java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例是线程安全的，并且在任何情况下，它都是一个单例。即使是在反序列化的过程，枚举单例也不会重新生成新的实例。