单例模式

单例模式是设计模式中比较简单和常用的一种，尤其是在spring中，默认的都是单例的，这样的好处是可以减少对gc的压力。

而单例模式的实现又分很多种其中最简单也是最安全的一种就是

public class Single {
	private final static Single single=new Single();
	private Single() {};
	public static Single getInstance() {
		return single;
	}
}

简单很容易理解，而这个安全就要通过对下面这几种实现方式的对比来进行理解

public class SingleTest {
	private static  SingleTest single;
	private SingleTest() {}
	public static SingleTest getInstance()  {
			if(single==null) {
				single=new SingleTest();
			}
		return single;
	}
}

这种方式 也可以简单的实现单例模式，但是在多线程环境下却容易产生问题，现在进行对代码进行简单的修改，来模拟这种情况的发生；

public class SingleTest {
	private static  SingleTest single;
	private SingleTest() {}
	public static SingleTest getInstance() throws InterruptedException {
		//延迟
			if(single==null) {
				Thread.sleep(1000);
				single=new SingleTest();
			}
		return single;
	}
	public void say() {
		System.out.println(this);
	}
}

测试类如下

public class TestMain {
	public static void main(String[] args) {
		List<Thread> list =new ArrayList<>();
		for(int i=0;i<3;i++) {
			Thread a=new Thread(new Runnable() {
				
				@Override
				public void run() {
					try {
						SingleTest.getInstance().say();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			},i+"");
			try {
				a.join();
				list.add(a);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
			}
			
		}
		for (Thread thread : list) {
			thread.start();
		}
	}
}

然后运行结果截图如下，通过运行结果我们可以发现此时产生的3个对象的堆地址是不一致的这也说明我们产生了3个不同的对象。

我们可以通过枷锁来避免这种情况的发生，修改后的代码如下

public class SingleTest {
	private static SingleTest single;
	private static ReentrantLock lock = new ReentrantLock();

	private SingleTest() {
	}

	public static SingleTest getInstance() throws InterruptedException {
		//延迟
		if(single==null) {
				if(lock.tryLock(100,TimeUnit.MICROSECONDS)) {
					Thread.sleep(1000);
					single=new SingleTest();
				}else {
						getInstance();
				}
			}
		return single;
	}

	public void say() {
		System.out.println(this);
	}
}

这样我们再运行一次测试类就会发现，我们产生的3个对象都是同一个对象。

然而这样单例模式还是会发生问题，因为在运行single=new SingleTest();这一行代码时候，jvm其实会执行3条指令 

第一步分配对象的内存空间

第二步初始化对象

第三步将single指向内存空间。

然而在jvm执行过程中，由于jvm会对指令进行重排，所以有可能会发生下面这种情况

而要避免这种情况的可以通过我们一开始提出的那种实现方法。