Java单例的一些思考

#Java 单例模式#
今天思考了一下单例模式,普通的懒汉模式会导致线程的不安全

public class Demo{
	private Demo(){
	}
	private static Demo instance;
	public static Demo getInstance (){
		if(instance==null){
			instance = new Demo();
		}
		return instance;
	}
}

怎样体现出来的线程不安全呢? 我们可以写个测试程序看看

public class Test {
	public static void main(String[] args) {
		Thread t1 = new Thread(){
			@Override
			public void run() {
				Demo d1 = Demo.getInstance();
				System.out.println(d1);
			}
		};
		
		Thread t2 = new Thread(){
			@Override
			public void run() {
				Demo d2 = Demo.getInstance();
				System.out.println(d2);
			}
		};
		t1.start();
		t2.start();
	}
}

这里写了两个线程,同时运行出来的结果如下:

从运行的结果可以看出来这样的结果是不安全的,无法满足单例模式的要求,这是我们就要加锁,于是引入如下的模式

1.双检索懒汉

// 双检索懒汉模式
public class Demo7 {

	private static volatile Demo7 instance;

	private Demo7() {
		
	}
	public static Demo7 getInstance() {
		// 粗选
		if (instance == null) {
			synchronized (Demo7.class) {
				// 细选
				if (instance == null) {
					instance = new Demo7();
				}
			}
		}
		return instance;
	}

}

2.懒汉模式静态内部类

// 懒汉模式静态内部类
public class Demo8 {
	private Demo8(){
	
	}
	public static Demo8 getInstance(){
		return InstanceHolder.instance;
	}
	
	public static class InstanceHolder{
		static Demo8 instance = new Demo8();
	}
}

3.饿汉模式

//饿汉模式
public class Demo9 {
	private Demo9(){
		
	}
	static Demo9 instance = new Demo9();
	public static Demo9 getInstance(){
		return instance;
	}
}