单例模式

动机：对于面向对象编程，总会有对象的存在，有时候希望在系统中只需要一个实例，这时候可以从性能上考虑优化使用单例模式

class SingleClass{
	//c++需要声明这个私有构造器，
	private SingleClass singleClass;
	public Lock lock;

	private SingleClass(){ ... }

	//线程不安全
	public SingleClass getInstance(){
		if(singleClass==null){
			singleClass=new SingleClass();
		}
		return singleClass;
	}
}

需要加锁

//性能变差，读写都上了锁
public SingleClass getInstance(){
		lock.getLock();
		if(singleClass==null && lock){
			singleClass=new SingleClass();
		}
		return singleClass;
	}

需要释放读的锁

//双检查锁，但由于内存读写reOrder不安全
public SingleClass getInstance(){
		if(singleClass==null){
			lock.getLock();
			if(singleClass==null && lock){
				singleClass=new SingleClass();
			}
		}
		return singleClass;
	}

singleClass=new SingleClass();
这一行代码有可能导致reorder，正常情况下对象创建(分配内存空间->调用class的构造器，初始化内存->将对象空间的引用赋值给singleClass)
然而事实上有可能是这样(分配内存空间->直接将没有初始化的内存空间引用给singleClass->再执行构造器)

那么假设两个线程A、B进入方法，A去初始化singleClass对象的时候reorder了，实际上singleClass不为null但是内存又没有初始化，B就会获取一个singleClass垃圾对象

Java和C++编译器就马上为了保证cpu层顺序操作而创建了一个关键字volatile，完美避免了reorder的问题，也就是增加内存屏障

public SingleClass getInstance(){
		if(singleClass==null){
			lock.getLock();
			if(singleClass==null && lock){
				singleClass=new SingleClass();
			}
		}
		return singleClass;
	}

这里顺便说一下饿汉模式和懒汉模式
饿汉模式：在类创建的时候，就创建实例
优点:线程安全，在类加载的同时已经创建好一个静态对象，调用时反应速度快
缺点:耗费内存。可能只是要他这个类的静态方法（不需要实例），但是加载class的时候仍然创建了实例

懒汉式就上面那些

/**
 * 饿汉式（推荐）
 *
 */
public class Singleton1 {

	private Singleton1() {
	}

	public static Singleton1 instance = new Singleton1();

	public Singleton1 getInstance() {
		return instance;
	}

}