单例的三种方案

单例: java的23种设计模式之一. 单例模式的类在同一个进程中, 有且只有1个实例.

    2种基础设计方案:
        1) 饿汉式: 效率高, 内存使用和数据安全性低
        2) 懒汉式: 效率低, 内存使用和数据安全性高
    
    变种方案:
        双重锁式:  结合了饿汉式和懒汉式两者的优点

示例:

package com.hanger;

import java.util.Calendar;

/**
 * 饿汉式单例示例
 * @author Administrator
 *
 */
public class Hanger {

	/* 1. 声明一个私有的静态的本类类型的成员变量 */
	//饿汉式需要在声明时, 直接对成员变量实例化
	private static Hanger hanger = new Hanger();
	
	/* 2. 将构造方法私有化 */
	private Hanger() {}
	
	/* 3. 提供一个共有的静态的用于获取本类实例的方法 */
	public static Hanger getInstance() {
		return hanger;
	}
}

package com.lazy;

/**
 * 懒汉式单例示例
 * @author Administrator
 *
 */
public class Lazy {

	/* 1. 声明一个私有的静态的本类类型的成员变量 */
	private static Lazy lazy;
	
	/* 2. 将构造方法私有化 */
	private Lazy() {}
	
	/* 3. 提供一个共有的静态的用于获取本类实例的方法 */
	//需要将方法同步
	public static synchronized Lazy getInstance() {
		//判断
		if(lazy == null) {
			lazy = new Lazy();
		}
		
		return lazy;
	}
}

package com.lock;

/**
 * 双重锁式单例示例
 * @author Administrator
 *
 */
public class Lock {

	/* 1. 声明一个私有的静态的本类类型的成员变量 */
	//建议添加volatile修饰
	private static volatile Lock lock;
	
	/* 2. 将构造方法私有化 */
	private Lock() {}
	
	/* 3. 提供一个共有的静态的用于获取本类实例的方法 */
	public static Lock getInstance() {
		
		//第1次判断
		if (lock == null) {
			//为第2次判断上锁
			synchronized (Lock.class) {
				//第2次判断
				if (lock == null) {
					lock = new Lock();
				}
			}
		}
		
		return lock;
	}
}