单例模式

一 懒汉模式

public class Singleton{
    private static Singleton singleton;

    private Singleton() {
    }

    public synchronized static Single newInstance() {
        if (singleton== null) {
            singleton= new Singleton();
        }
        return singleton;
    }
}

 

　　懒汉模式在类加载的时候就实例化对象，这种模式缺点是不用这个对象的时候也会消耗内存，优点是线程安全。

二 饿汉模式

public class Singleton{  
    private static Singleton instance = null;  
    private Singleton(){}  
    public static Singleton newInstance(){  
        if(null == instance){  
            instance = new Singleton();  
        }  
        return instance;  
    }  
} 

　　饿汉模式在我们需要用这个对象再去实例化对象，缺点是线程不安全，有可能实例化了两个对象，优点是不实例化的时候不消耗内存。

　　以上两种单例都不是完美的单例，如果饿汉模式能线程安全就更完美了，线程安全自然想到加锁，但锁加的不好会非常消耗性能，如以下加锁方式就非常消耗性能：

public class Singleton{  
    private static Singleton instance = null;  
    private Singleton(){}  
    public static synchronized Singleton newInstance(){  
        if(null == instance){  
            instance = new Singleton();  
        }  
        return instance;  
    }  
} 

　　上面的代码虽然实现了线程安全，但是每次拿对象的时候都要排队，用的人多的时候就非常消耗性能了。

三 双重检查加锁

　　这个方式还是基于饿汉模式，如果我们能在创建对象的时候加锁，那么就完美的解决了性能的问题，并且线程也安全了。

 

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

四 静态内部类

public class Singleton{  
    private static class SingletonHolder{  
        public static Singleton instance = new Singleton();  
    }  
    private Singleton(){}  
    public static Singleton newInstance(){  
        return SingletonHolder.instance;  
    }  
}

　　这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。