java单例模式

第一种：简单懒汉式

/**
 * 懒汉式
 */
public class LazySingleInstance {

	// 私有构造方法
	private LazySingleInstance(){};
	
	// 私有的类对象
	private static LazySingleInstance instance = null;
	
	// 缺点：
	// 1 每次都需要去判断instance 是否为空
	// 2 调用时才去new对象，响应比较慢
	// 3 多线程时，线程不安全，多线程同时获取该对象，线程不安全，可能会产生多个对象出来
	public static LazySingleInstance getInstance() throws InterruptedException {
		// 每次都需要判断instance是否为空，浪费资源
		if (null == instance) {
			Thread.sleep(1000);
			instance = new LazySingleInstance();
		}
		
		return instance;
	}
}

懒汉式线程安全一

/**
 * 懒汉式线程安全方法一
 */
public class ThreadSafeSingleInstance {

	// 私有的静态实例
	private static ThreadSafeSingleInstance instance;
	
	// 私有的构造方法
	private ThreadSafeSingleInstance(){};
	
	/**
	 * 懒汉式线程安全方法
	 * 同步锁保护
	 * 缺点：
	 * 性能低下，且同时每次均需检查实例是否存在
	 * @return
	 * @throws InterruptedException 
	 */
	public synchronized static ThreadSafeSingleInstance getInstance() throws InterruptedException {
		if (instance == null) {
			Thread.sleep(1000);
			instance = new ThreadSafeSingleInstance();
		}
		
		return instance;
	}
	
}

懒汉式线程安全二

/**
 * 懒汉式线程安全方法二
 */
public class ThreadSafeSingleInstance {

	// 私有的静态实例
	private static ThreadSafeSingleInstance instance;
	
	// 私有的构造方法
	private ThreadSafeSingleInstance(){};
	
	/**
	 * 同步块保护加二次判断
	 * 解决问题
	 */
	public static ThreadSafeSingleInstance getInstance() throws InterruptedException {
		if (instance == null) {
			// 进方法后进行实例判断，若实例为空，进入同步块
			// 多线程时，多个线程会同时进入到同步块外面等待
			// 此时，一个线程拿到ThreadSafeSingleInstance.class 后，其他线程在synchronized块外面等待
			// 待锁释放时，一个等待的线程拿到锁，同时再次检查实例是否为空
			// 并决定是否要创建实例
			synchronized (String.class) {//ThreadSafeSingleInstance.class) {
				Thread.sleep(1000);
				if (instance == null) {
					instance = new ThreadSafeSingleInstance();
				}
			}
		}
		
		return instance;
	}
	
}

饿汉式

/**
 * 饿汉式
 */
public class HungrySingleInstance {

	// 私有的构造方法
	private HungrySingleInstance(){};
	
	// 静态类变量,初始化类时变创建对象
	private static HungrySingleInstance instance = new HungrySingleInstance();
	
	// 或采用静态块形式初始化instance
	static {
		instance = new HungrySingleInstance();
	}
	
	/**
	 * 获取实例方法
	 * 优点：
	 * 线程安全，且不存在懒汉式的二次判断问题
	 * 缺点：
	 * 初始化即new 实例对象出来，违背资源利用习惯（即不管用不用都初始化实例出来）
	 * @return
	 */
	public static HungrySingleInstance getInstance() {
		return instance;
	}
}

测试类

public class SingleInstanceTest implements Runnable{

	HungrySingleInstance hungrySingleInstance = null;
	
	LazySingleInstance lazySingleInstance = null;
	
	ThreadSafeSingleInstance threadSafeSingleInstance = null;
	
//	@Override
//	public void run() {
//		hungrySingleInstance = HungrySingleInstance.getInstance();
//		System.out.println("hungrySingleInstance.hashCode() " + hungrySingleInstance.hashCode());
//		
//	}
	
//	@Override
//	public void run() {
//		try {
//			lazySingleInstance = LazySingleInstance.getInstance();
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}
//		System.out.println("lazySingleInstance.hashCode() " + lazySingleInstance.hashCode());
//	}
	
	@Override
	public void run() {
		try {
			threadSafeSingleInstance = ThreadSafeSingleInstance.getInstance();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("threadSafeSingleInstance() " + threadSafeSingleInstance.hashCode());
	}

	public static void main(String args[]) throws InterruptedException{
		SingleInstanceTest singleInstanceTest = new SingleInstanceTest();
		
		for (int i=0; i< 100; i++) {
			Thread t = new Thread(singleInstanceTest, String.valueOf(i));
			t.start();
		}
	}
}