单例模式代码分析

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {
private Singleton(){}
　　    //在自己内部定义自己一个实例，是不是很奇怪？
　　    //注意这是private 只供内部调用
　　    private static Singleton instance = new Singleton();
　　    //这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　    public static Singleton getInstance() {
　　　　    return instance; 　　
　　    } 
    } 

    第二种形式: 

public class Singleton { 
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　} 
} 

在上面两中形式中 各有优势，看具体怎么使用、

一般认为第一种形式要更加安全些 

补充

/**
 * 单例模式
  * @className: Singleton
  * @description:
  * @author: singleton-zw
  * @createDate: 2016年3月4日-下午3:19:07
  * @updateAuthor:
  * @updateDate:
  * @updateDesc:
  * @version: v1.0
  * @Copyright (c)-2016
 */
//恶汉,缺点：没有达到lazy loading的效果
public class Singleton {
	
	private static Singleton singleton = new Singleton();

	private Singleton() {
	}
	public static Singleton getInstance(){
		return singleton;
	}
}

//懒汉，常用的写法
class SingletonA{
	private static SingletonA a;
	private SingletonA() {}
	
	public static SingletonA getInstanceA(){
		if(a==null) return a = new SingletonA();
		return a;
	}
}
/**
 * 枚举，《Effective Java》作者推荐使用的方法，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
 */
enum EnumSingleton{
    INSTANCE;
    public void doSomeThing(){
    }
}

/**
 * 静态内部类 优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading
 */
class InternalSingleton{
    private static class SingletonHolder{
        private final static  InternalSingleton INSTANCE=new InternalSingleton();
    }   
    private InternalSingleton(){}
    public static InternalSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

/**
 * 双重校验锁，在当前的内存模型中无效
 */
class LockSingleton{
    private volatile static LockSingleton singleton;
    private LockSingleton(){}

    public static LockSingleton getInstance(){
        if(singleton==null){
            synchronized(LockSingleton.class){
                if(singleton==null){
                    singleton=new LockSingleton();
                }
            }
        }
        return singleton;
    }
     
}