单例模式的实现之懒汉，饿汉，双重校验锁，枚举和静态内部类以及单例模式的应用情景

转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/6413270.html

 在项目中的应用见： https://github.com/ygj0930/CoupleSpace

    何为单例模式?单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这样可以避免重复创建对象导致内存占用过多等问题。也就是说，这个实例被创建后，在别的地方需要用时，直接获取已创建好的对象来使用即可，不需要重新创建一个。那么，怎么实现呢？

    一：懒汉模式

    懒汉模式的要点在于：不提供外界调用的类构造函数，只能通过  类名.getInstance()  方法去获得实例。而第一次调用时，没有这个实例，所以类会创建这个实例。之后调用时直接返回这个实例，而不会重复创建。

//单线程下的单例，最简单的单例
public class LazySingleton {
    private static LazySingleton s=null;
    private LazySingleton(){}
    public static LazySingleton getInstance(){
        if(s==null){
            s=new LazySingleton();
        }
        return s;
    }    
}
//多线程下的单例，用同步锁保证了同一时间只能有一个线程调用getInstance()方法。这里最主要是防止多个线程同时进行第一次调用getInstance()导致多个实例被创建
public class LazySingleton {
    private static LazySingleton s=null;
    private LazySingleton(){}
    public static synchronized LazySingleton getInstance(){        
        if(s==null){
            s=new LazySingleton();
        }
        return s;
    }    
}

    二：饿汉模式

    饿汉模式是类一加载就创建好类实例。然后在任何时候别的地方通过 类名.getInstance() 时把创建好的实例返回就好。

public class StarveSingleton {
    private static StarveSingleton s=new StarveSingleton();    
    private StarveSingleton(){}
    public static StarveSingleton getInstance(){        
        return s;
    }    
}

    三：双重校验锁Double-Check

    双重校验锁提供了更精确的控制：在上面我们知道，多线程下单例模式不安全的地方就在于第一次创建实例时，如果有多个线程同时调用请求，则可能同时多个线程执行了实例的创建造成浪费。在懒汉模式的第二种方法中，我们通过限制getInstance()方法每时刻只能有一个线程占用的方法来防止创建多个实例。但是这样也限制了之后每时刻只能有一个线程获取实例对象。显然这个限制有些大了，我们只需要限制创建部分即可。可以通过下面方式实现：

public class LazySingleton {
    private static Object initLock = new Object();//一个静态对象作为锁钥匙。由于是静态的，内存中只有一个这个对象。
    private static LazySingleton s=null;
    private LazySingleton(){}
    public static LazySingleton getInstance(){        
        if (s == null) {//如果实例为空才创建实例，否则直接返回实例。这就使得实例创建后可以多线程同时调用getInstance()方法来获取实例。   
            synchronized (initLock) {//保证了同一时间，只能有一个对象访问此同步块。由于锁钥匙是静态的，内存中只有一个，所以只有抢到了这个锁对象的线程才能执行创建操作 
                if (s == null) {   
                    s = new LazySingleton();   
                }   
            }
        }   
        return s;
        /*//也可以这样处理
        if (s == null) {   
            synchronized (LazySingleton.class) {//保证了同一时间，只能有一个对象访问此同步块 
                if (s == null) {   
                    s = new LazySingleton();   
                }   
            }   
        }   
        return s;*/
    }
}

    四：枚举

//使用enum关键字来实现单例模式的好处是这样非常简洁，并且无偿地提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候
public enum EnumSingleton{
    INSTANCE;
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }

    五：静态内部类

    定义一个静态内部类，内部类中有一个静态属性持有外部类对象。这样在类被加载的时候内部类就创建好了一个静态属性而且这个属性指向一个外部类对象。每次外部类调用getInstance()时其实就是获取内部类中的静态属性。

public class Test {
    public static Test getInstance() {
        return TestInstance.getInstance();
    } 
    private static class TestInstance {
        private static Test instance = new Test(); 
        private TestInstance() {
        } 
        private static Test getInstance() {
            return instance;
        }
    }
}

     六：单例模式在J2EE中的应用

     单例模式在J2EE中一般用于service层、Utils、DAO层。我们在control层的时候经常需要通过service对象调用业务方法，而其实这个service对象只是提供一个调用的入口而已。如果在control层中每个servlet都创建一个service对象无疑是很浪费的。同理，在每个service类中创建DAO层对象调用数据库操作方法也是很浪费的。由此可见，单例模式主要应用在避免重复创建对象造成内存浪费。