单例模式代码实现

双检查锁机制（Double Check Locking）实现

public class Singleton {
	//使用 volatile 关键字保变量可见性 
    private volatile static Singleton instance = null; 
    private Singleton(){} //私有化构造方法
    public static Singleton getInstance() { 
        if(instance == null){
		    synchronized (Singleton.class) { 
		        if(instance == null){//二次检查  
		        	instance = new Singleton(); 
		        } 
		    } 
		} 
        return instance; 
    } 
}

在声明变量时使用了 volatile 关键字来保证其线程间的可见性；在同步代码块中使用二次检查，以保证其不被重复实例化
同时在调用getInstance()方法时不进行同步锁，效率高。这种实现方式既保证了其高效性，也保证了其线程安全性。

静态内置类方式实现

public class Singleton {
    private static class SingletonHandler{ 
        private static Singleton instance = new Singleton(); 
    } 
    private Singleton(){} 
    public static Singleton getInstance() { 
        return SingletonHandler.instance; 
    }
}

第一次加载Singleton类时不会初始化instance，只有在第一次调用getInstance()方法时，虚拟机会加载SingletonHolder类，初始化instance。

这种方式既保证线程安全，单例对象的唯一，也延迟了单例的初始化，推荐使用这种方式来实现单例模式。

枚举方式实现

public class ClassFactory {
	private enum EnumSingleton{ //将枚举类封装，遵循"职责单一原则"
		singletonFactory; 
        private Singleton instance; 
        private EnumSingleton(){//枚举类的构造方法在类加载时被实例化 
            instance = new Singleton(); 
        } 
        public Singleton getInstance(){ 
            return instance; 
        } 
	}
	public static Singleton getInstance(){ 
        return EnumSingleton.singletonFactory.getInstance(); 
    } 
}
class Singleton {//需要获实现单例的类，比如数据库连接 Connection  
    public Singleton(){} 
}

在使用枚举时，构造方法会被自动调用，利用这一特性也可以实现单例；默认枚举实例的创建是线程安全的，即使反序列化也不会生成新的实例，任何情况下都是一个单例。