单例模式

 /** *//**
  * @author lx
  * 线程不安全的单例，试想两个线程都进入了if(singleton==null)块里这个时候会初始化两个对象，这只在第一次调用的时候会产生
  */
 public class Unsafe_singleton {
 
     private static Unsafe_singleton singleton;
 
     private Unsafe_singleton() {
    }

    public static Unsafe_singleton getInstance() {
        if (singleton == null) {
            singleton = new Unsafe_singleton();
        }
        return singleton;
    }
}
public class Safe_singleton {
     
    private static Safe_singleton singleton;

    private Safe_singleton() {
    }

    /** *//**
     * 这种写法，非常消耗性能，因为只是第一次进来的时候可能会产生多个实例的情况，后面多线程都不会再进行实例化，那么调用的时候会很降低性能
     * @return
     */
    public static synchronized Safe_singleton getInstance() {
        if (singleton == null) {
            singleton = new Safe_singleton();
        }
        return singleton;
    }
}
/** *//**
 * @author lx
 * 这种写法如果在创建和运行时的负担不太繁重，那么这种写法也可以保证多线程安全，每个线程进来都会new 创建此实例。
 * 这种单例相对于每个线程来说确实是唯一的
 */
public class MoreSafe_singleton {
        
    private static MoreSafe_singleton singleton = new MoreSafe_singleton();
    
    public static MoreSafe_singleton getInstance(){
        return singleton;
    }
}
/** *//**
 * @author lx
 * volatile 这个只在JDK1.5以上出现 它确保singleton变量被初始化时，多个线程正确地处理singleton变量
 * 这种写法如果性能是关注的重点，那么可以大大减少getInstance()的时间消耗
 */
public class VerySafe_singleton {
     
    private volatile static VerySafe_singleton singleton;
    private VerySafe_singleton(){}
    
    public static VerySafe_singleton getInstance(){    
        if(singleton==null){
            synchronized(VerySafe_singleton.class){    
                if(singleton==null){ //里面为何在加上判断是否为空？
                    //因为试想如果有三个线程其中一个线程刚刚走出synchronized块，这个时候又进来一个线程，
                    //如果不判断是否为空，这个又会实例一个变量那么就不是单例了
                    singleton=new VerySafe_singleton();
                }
            }
        }
        return singleton;
    }
}