单例模式----设计模式系列

这次主要写了四种类型的单例模式

• 饿汉式
• 懒汉式
• 同步方法锁
• 双重锁定

自己留着以后忘记时查看用的，所以注释比代码都多。项目结构很简单，一个Singleton类，一个测试类。直接上代码了。

package com.dyk.singleton;

public class Singleton {

	private static Singleton mSingleton;

	/**
	 * <b>饿汉式单例</b>
	 * <p>
	 * 静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称为饿汉式单例类
	 */
	private static Singleton mSingleton2 = new Singleton();

	/** <b>饿汉式单例</b> */
	public static Singleton getInstance5() {
		return mSingleton2;
	}

	/** 私有化构造方法，防止从外界直接创建对象。 */
	private Singleton() {

	}

	/**
	 * <b>懒汉式单例。</b>在多线程模型下可能产生多个实例。 例如：当两个线程同时运行到new Singleton()那一行，则会产生两个对象。
	 * @return instanceof Singleton
	 */
	public static Singleton getInstance() {
		if (mSingleton == null) {
			mSingleton = new Singleton();
		}
		return mSingleton;
	}

	/**
	 * 运用同步锁机制，锁住获取实例的方法。 优点：可以保证一个类中只有一个实例。
	 * 缺点：在多线程环境下，第一个线程进入getInstance2()方法后，其余线程都必须等待，直到第一个线程释放资源
	 * 假设有100个线程，那么第一百个线程需要等待前99个线程全部释放资源后才能进入getInstance2()方法
	 * 
	 * @return instanceof Singleton
	 */
	public static synchronized Singleton getInstance2() {
		if (mSingleton == null) {
			mSingleton = new Singleton();
		}
		return mSingleton;
	}

	/**
	 * 和getInstance2()很类似。
	 * 区别是getInstance2()锁住的是方法，在线程访问getInstance2()的同时，其他线程可以访问Singleton类的其他方法。
	 * 而getInstance3()锁住的是整个类，独占了整个类的访问。
	 * @return instanceof Singleton
	 */
	public static Singleton getInstance3() {
		synchronized (Singleton.class) {
			if (mSingleton == null) {
				mSingleton = new Singleton();
			}
		}
		return mSingleton;
	}

	/**
	 * <b>双重锁定(Double-Check-Locking)</b><br/>
	 * 在synchronized关键字内还要再进行一次判空是因为：<br/>
	 * 如果同时有两个线程调用GetInstace4()方法时，<br/>
	 * 它们都将可以通过第一重mSingleton==null的判断。<br/>
	 * 然后由于synchronized机制，这两个线程只有一个可以进入。然后由第一个进入的线程创建相应的实例。<br/>
	 * 如果没有第二重判断，则会创建出两个实例，这明显与单例精神不符。
	 * @return instanceof Singleton
	 */
	public static Singleton getInstance4() {
		if (mSingleton == null) {
			synchronized (Singleton.class) {
				if (mSingleton == null) {
					mSingleton = new Singleton();
				}
			}
		}
		return mSingleton;
	}

}

package com.dyk.singleton;

public class SingletonTest {

	public static void main(String[] args) {

		// hungerManTest();
		// lazyManTest();
		// synchronizedTest();
		// doubleCheckLockingTest();

	}

	private static void doubleCheckLockingTest() {
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Singleton mSingleton = Singleton.getInstance4();
					System.out.println("Thread name="
							+ Thread.currentThread().getName() + "实例内存地址="
							+ mSingleton.toString());
				}
			}).start();
		}
	}

	private static void synchronizedTest() {
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Singleton mSingleton = Singleton.getInstance2();
					System.out.println("Thread name="
							+ Thread.currentThread().getName() + "实例内存地址="
							+ mSingleton.toString());
				}
			}).start();
		}
	}

	/** 懒汉式单例测试 */
	private static void lazyManTest() {
		for (int i = 0; i < 10; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					// 一次测试不一定成功，需要多运行几次
					Singleton mSingleton = Singleton.getInstance();
					System.out.println("Thread name="
							+ Thread.currentThread().getName() + "实例内存地址="
							+ mSingleton.toString());
				}
			}).start();
		}
	}

	/** 饿汉式单例测试 */
	private static void hungerManTest() {
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					Singleton mSingleton = Singleton.getInstance5();
					System.out.println("Thread name="
							+ Thread.currentThread().getName() + "实例内存地址="
							+ mSingleton.toString());
				}
			}).start();
		}
	}

}