单例的几种方式，以及如何破坏单例，使用枚举保护单例；

1、基础入门单例：

public class Singleton {
    private Singleton(){
        System.out.println("Singleton 初始化的过程");
    }
    
    private static Singleton singleton = null;
    
    /**@Description: 单例同步控制，方法加syn
     * @return
     * @author BIQI  2017年12月20日下午3:10:23
     * @return Singleton  @throws
     */
    public static synchronized Singleton getSingleton1(){
        if (null == singleton ) {
            singleton = new Singleton();
        }
        return singleton;
    }
    
    /**@Description: 单例同步控制2，使用ReentrantLock锁
     * @return
     * @author BIQI  2017年12月20日下午3:14:16
     * @return Singleton  @throws
     */
    public static Singleton getSingleton2(){
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        if (null == singleton ) {
            singleton = new Singleton();
        }
        lock.unlock();
        return singleton;
    }
    
    /**@Description: 双重检测机制  DCL（Double CheckLock）实现单例
     * @return
     * @author BIQI  2017年12月20日下午3:15:31
     * @return Singleton  @throws
     */
    public static  Singleton getSingleton3(){
        //第一重检测
        if (null == singleton ) {
            synchronized (singleton) {
                //第二重检测
                if (null == singleton) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

2、单例的进阶，控制指令重排

public class Singleton2 {
    
    /*
     * 指令重排是 
          比如java中简单的一句 instance = new Singleton，会被编译器编译成如下JVM指令：
        memory =allocate();    //1：分配对象的内存空间 
        ctorInstance(memory);  //2：初始化对象 
        instance =memory;     //3：设置instance指向刚分配的内存地址 
        
        但是这些指令顺序并非一成不变，有可能会经过JVM和CPU的优化，指令重排成下面的顺序：
        
        memory =allocate();    //1：分配对象的内存空间 
        instance =memory;     //3：设置instance指向刚分配的内存地址 
        ctorInstance(memory);  //2：初始化对象 
     */
    
    private Singleton2() {
        System.out.println("Singleton 初始化的过程");
    }  
    
    //volatile 阻止变量访问前后指令的重排，保证指令执行顺序
    private volatile static Singleton2 singleton = null;  //单例对象
    
    //静态工厂方法
    public static Singleton2 getInstance() {
        if (singleton == null) {      //双重检测机制
            synchronized (Singleton.class){  //同步锁
                if (singleton == null) {     //双重检测机制
                    singleton = new Singleton2();
                    }
                }
            }
        return singleton;
    }
}

3、classloader的加载机制来实现懒加载单例实现

public class Singleton3 {
    /**
     * 1.从外部无法访问静态内部类LazyHolder，
     * 只有当调用Singleton.getInstance方法的时候，
     * 才能得到单例对象INSTANCE。
     * 2.INSTANCE对象初始化的时机并不是在单例类Singleton被加载的时候，
     * 而是在调用getInstance方法，使得静态内部类LazyHolder被加载的时候。
     * 因此这种实现方式是利用classloader的加载机制来实现懒加载，
     * 并保证构建单例的线程安全。
     * 
     */
    private static class LazyHolder {
        private static final Singleton3 INSTANCE = new Singleton3();
    }
    private Singleton3 (){}
    public static Singleton3 getInstance() {
        return LazyHolder.INSTANCE;
    }
}

4、最推荐的单例，使用枚举，因为枚举的特性以及实现方式（这里不阐述）；

    常量实际是被编译为静态变量，Java中静态变量都是存储在Method Area

public enum SingletonEnum1 {
    
    INSTANCE();
    
    SingletonEnum1(){
        System.out.println("SingletonEnum1 初始化的过程");
    }
}

5、如何破坏单例模式，如果不适用枚举的话；

/**
 * @Title: BreakSingleton.java
 * @Description: 破坏单例的情况，后面通过枚举去破解
 *  
 * @author BIQI IS BEST
 * @date 2017年12月20日 下午3:27:39
 * @version V1.0
 */
public class BreakSingleton {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // TODO Auto-generated method stub
        
        //获得构造器
        Constructor con = Singleton.class.getDeclaredConstructor();
        //设置为可访问
        con.setAccessible(true);
        //构造两个不同的对象
        Singleton singleton1 = (Singleton)con.newInstance();
        Singleton singleton2 = (Singleton)con.newInstance();
        //验证是否是不同对象
        System.out.println(singleton1.equals(singleton2));
        
        //枚举类的获得
        SingletonEnum1 singletest1 =SingletonEnum1.INSTANCE;
        SingletonEnum1 singletest2 =SingletonEnum1.INSTANCE;
        System.out.println(singletest1.equals(singletest2));
    }
}