Java单例设计模式，多线程下同步

单例模式的特点：

1. 只创建一次
2. 私有的属性
3. 公有的访问方法

单例模式的分类：

1. 懒汉（LazySingleton）；默认不自动实例化，等到用的时候根据当前情况实例化，并且返回当前对象；
2. 恶汉（EagerSingleton）；在类第一次加载的时候强制实例化；
   

用处：

         一般用在配置文件的读取，有些东西只需要加载一次，以后重复使用。

示例代码：

package myThread;

/**
 * 单例模式，懒汉模式
 * 
 * @author Champion.Wong
 * 
 */
public class LazySingleton {

	private static LazySingleton singleton = null;

	/**
	 * 私有的构造方法，防止被多次实例化
	 * 
	 */
	private LazySingleton() {
	}

	/**
	 * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回
	 * 
	 * @return LazySingleton
	 */
	public static LazySingleton getInstance() {
		if (null == singleton)
			singleton = new LazySingleton();
		return singleton;
	}
}

package myThread;

/**
 * 单例模式，饿汉模式
 * @author Champion.Wong
 *
 */
public class EagerSingleton {

	private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象

	/**
	 * 私有的构造方法，防止被多次实例化
	 * 
	 */
	private EagerSingleton() {
	}

	public static EagerSingleton getInstance() {
		return singleton;
	}
}

前边说过了，单例只创建一次，来做个测试，在单例的类中加入一个属性，当这个类在实例化的时候，会将当前的时间赋给这个属性。我们创建两个单例类的对象，然后分别拿出它们类中的这个属性进行对比。

所以，在EagerSingleton中加入属性：createdTime

package myThread;

/**
 * 单例模式，饿汉模式
 * @author Champion.Wong
 *
 */
public class EagerSingleton {

	private static EagerSingleton singleton = new EagerSingleton(); // 强制初始化，在类加载的时候就创建好了对象

	/**
	 * 私有的构造方法，防止被多次实例化
	 * 
	 */
	private EagerSingleton() {
		createdTime = System.currentTimeMillis();
	}

	public static EagerSingleton getInstance() {
		return singleton;
	}
	
	private long createdTime = 0L; //此类的创建时间，在类实例化的时候赋值
	public long getCreatedTime() {
		return createdTime;
	}
}

然后，写个Test：

package myThread;

public class Test_Singleton {

	public static void main(String[] args) {
		EagerSingleton singleton1 = EagerSingleton.getInstance();
		try {
			Thread.sleep(2000); //让当前线程睡眠2000ms，这样，两个对象实例化的时间就差2s
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		EagerSingleton singleton2 = EagerSingleton.getInstance();
		
		System.out.println("Singleton1:" + singleton1.getCreatedTime());
		System.out.println("Singleton2:" + singleton2.getCreatedTime());
	}

}

最后控制台输出的内容为：

两个对象的实例化的时间相同，证明单例设想成功！

当多个线程访问单例类的时候，必须要保证同时只能由一个线程访问，当这个线程访问结束了，其它线程才能访问。这是就要给单例的访问方法加个同步锁（synchronized）。

修改后的LazySingleton为：

package myThread;

/**
 * 单例模式，懒汉模式
 * 
 * @author Champion.Wong
 * 
 */
public class LazySingleton {

	private static LazySingleton singleton = null;

	/**
	 * 私有的构造方法，防止被多次实例化
	 * 
	 */
	private LazySingleton() {
	}

	/**
	 * 静态工厂，返回此类的唯一一个实例 判断，如果没有被实例化，则先初始化再返回
	 * 
	 * @return LazySingleton
	 */
	synchronized public static LazySingleton getInstance() {
		if (null == singleton)
			singleton = new LazySingleton();
			System.out.println(Thread.currentThread().getName() + System.currentTimeMillis());
		try {
			Thread.sleep(900); //假设每个线程访问的时候都需要耗费一定的时间
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return singleton;
	}
}

做个测试，起两个线程，没个线程中分别调用单例类的访问方法，每次访问的时候输出访问的时间，判断时间是否相等。如果相等，同步失败，如果不等，同步成功！

package myThread;

public class Test_Thread_Singleton {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		SingletonThread st = new SingletonThread();
		SingletonThread st1 = new SingletonThread();
		st.start();
		st1.start();
	}

}

class SingletonThread extends Thread {
	private LazySingleton singleton = null;
	public void run() {
		while (!this.isInterrupted()) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			singleton = LazySingleton.getInstance();
		}
	}
}

看控制台的输出内容：

时间差不多都不一致，同步成功！限制了同时访问。