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();
		}
	}
}



你可能感兴趣的:(java,单例模式)