package singleton;
/**
 * 懒汉式单列模式
 * @author Administrator
 * @优点：单例只有在使用的时候才会初始化化，在一定程度上节约了资源。
 * @缺点：第一次加载时需要及时的进行初始化，反应稍微慢，最大的问题是每次调用getInstance
 * 都是同步，造成了不必要的开销，一般不建议使用。
 */
public class Singleton {

	private static Singleton instance;
	
	private Singleton(){}
	//同步方法
	public static synchronized Singleton getInstance(){
	
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
		
	}
	
	public static void main(String[] args) {
		System.out.println();
	}
	
}

package singleton;

/**
 * 
 * @author lidong
 * @优点：既能够在需要的时候初始化单例，又能够保证线程安全。 并且单例对象初始化后调用getInstance不进行同步锁。
 * @延迟加载方式
 */
public class Singleton1 {

	private static Singleton1 instance = null;

	private Singleton1() {
	}

	public static Singleton1 getInstance() {

		if (instance == null) {//避免不必要的同步
			synchronized (Singleton1.class) {
				if (instance == null) {//为null的时候创建实例
					instance = new Singleton1();
				}
			}
		}
		return instance;
	}
}

package singleton;
/**
 * 饿汉式单例
 * @author lidong
 * @预先加载方式
 */
public class Singleton2 {

	
	private static Singleton2 instance = new Singleton2();

	private Singleton2() {
	}
	
	public static  Singleton2 getInstance(){
		return instance;
		
	}
	
	
}

package singleton;

public class Test {
	
	public static void main(String[] args) {
		//饿汉式
		Singleton2 s1 = Singleton2.getInstance();
		Singleton2 s2 = Singleton2.getInstance();
		System.out.println(s1.equals(s2));
		
		//懒汉式
		Singleton s3 = Singleton.getInstance();
		Singleton s4 = Singleton.getInstance();
		System.out.println(s3.equals(s4));
		
		//双枷锁模式
		Singleton1 s5 = Singleton1.getInstance();
		Singleton1 s6 = Singleton1.getInstance();
		System.out.println(s5.equals(s6));
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		System.out.println(s5);
		System.out.println(s6);
	}
	

}

true
true
true
singleton.Singleton2@12b6651
singleton.Singleton2@12b6651
singleton.Singleton@4a5ab2
singleton.Singleton@4a5ab2
singleton.Singleton1@1888759
singleton.Singleton1@1888759