单例模式是比较常见的设计模式。
是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。
单例模式的优点
我们从单例模式的定义和实现，可以知道单例模式具有以下几个优点：
在内存中只有一个对象，节省内存空间；
避免频繁的创建销毁对象，可以提高性能；
避免对共享资源的多重占用，简化访问；
为整个系统提供一个全局访问点。
- 有状态的工具类对象；
- 频繁访问数据库或文件的对象；
单例模式的使用场景
由于单例模式具有以上优点，并且形式上比较简单，所以是日常开发中用的比较多的一种设计模式，其核心在于为整个系统提供一个唯一的实例，其应用场景包括但不仅限于以下几种：
- 有状态的工具类对象；
- 频繁访问数据库或文件的对象；
1.第一种（懒汉式）：
public class Singleton(){ public static Singleton sInstance = null; //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。 private Singleton(){ } public static Singleton getInstance(){ if (sInstance == null ) { sInstance = new Singleton(); } return sInstatce; } private void getValue(){ System.out.println("this is the easy singleton!"); } } 在其他类里使用：
mSingleton.getValue();
这个写法缺点：
特点
缺点：单线程使用是没问题的，但是我们的web开发都是需要并发的，所以这个代码适用场景较小,线程不安全
第二种（懒汉式）
public class Singleton1 () { public static Singleton1 sInstance = null; public Singleton1 () { } public static Synchronized Singleton1 getInstance () { if (sInstance == null) { sInstance = new Singleton1(); } return sInstance; } }这种写法在getInstance()方法中加入了synchronized锁。能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading(延迟加载)，但是效率很低（因为锁），并且大多数情况下不需要同步。
第三种 （饿汉式）:
public class Singleton3(){ public static Singleton3 sInstance = new Singleton3(); private Singleton3() { //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。 } public static Singleton3 getInstance() { return sInstance; } }这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，这时候初始化instance显然没有达到lazy loading的效果
2.第四种（恶汉式，）：
public class Singleton1(){ public static Singleton1 sInstance = null; static { //在构造函数前就进行实例化 sInstance = new Singleton1(); } private Singleton1() { //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。 } public static Singleton1 getInstance() { return sInstance; } }都是在类初始化中即实例化sInstance.
优点
缺点：不是延迟加载的，当构造这样的单例非常重量级，但是这个单例可能很久也用不到一次的时候比较受伤。（这样的场景比较少）(意思是占用内存)第五种（静态内部类）：
public class Singleton5(){ public static class SingletonHolder(){ private static sInstance = null; static { sInstance = new Singleton5(); } } public Singleton5(){ //构造函数声明为private，是阻止外部实例化这个类。因为默认无参数构造方法是public的。 } public static Singleton5 getInstance() { return SingletonHolder.sInstance; } public static final void main (String[] args) { System.out.prinln("do anything"); } }这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方法就显得更合理。
第六种（枚举）：
enum Singleton6{ sInstance; public void getInstatnce() { System.out.println("something"); } }它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。如果用枚举去实现一个单例，这样的加载有点类似于饿汉模式.
3.防止反射攻击。(因为enum实际上是abstract的)
第七种(double check locked)
public class Singleton7 () { public static volatile Singleton7 sInstance = null; public Singleton7 () { } public static Singleton7 getInstance () { if (sInstance == null) { Synchronized(Singleton7.class){ if (sInstance == null) { sInstance = new Singleton7(); } } } return sInstance; } }双重检查锁定（DCL），若没有volatile 修饰，有因为内存模型的问题，会存在指令重排的问题。
增加了volatile修饰后：
规则1可以确保外层null检查要么看到的是null，要么看到的是一个构造完整的对象，规则2可以解决之前浪费的问题。
问题点1：
单例模式唯一实现为什么必须要静态？
单例模式实现过程：
1.构造方法进行私有化修饰，防止直接被创建实例
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { ・・・・ /** * prevent default deserialization */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { throw new InvalidObjectException("can't deserialize enum"); } private void readObjectNoData() throws ObjectStreamException { throw new InvalidObjectException("can't deserialize enum"); } }一般情况下，单例类实现了序列化接口，readObject会一直返回新的对象，会破坏单例，所以可以在类中实现如下方法：
//readResolve to prevent another instance of Singleton private Object readResolve(){ return INSTANCE; }问题3:
为什么枚举单例可以线程安全？
根据反编译枚举单例的代码来看，创建对象是在静态代码块中实现，静态代码快会在类创建初始化时就执行，可以保证安全.