单例模式

单例模式：
    单例类只能有一个实例，单例类必须自己创建自己的唯一实例
    单例类必须给所有其他对象提供这一实例

package com.jbx.singleton;

/**
 * 懒汉
 * 双重判断
 * @author Administrator
 * 
 */
public class SingletonAA {
	private static SingletonAA instance;

	private SingletonAA() {
	}

	public static SingletonAA getInstance() {
		if (instance == null) {
			synchronized(SingletonAA.class){
				if (instance == null){
					instance = new SingletonAA();
				}
			}
		}
		return instance;
	}
	
	public static void printInfo(){
		System.out.println(instance);
	}

	public static void main(String[] args) {
		SingletonAA t1 = SingletonAA.getInstance();
		t1.printInfo();
		
		SingletonAA t2 = SingletonAA.getInstance();
		t2.printInfo();
		
		SingletonAA t3 = SingletonAA.getInstance();
		t3.printInfo();
		
	}
}

双重检查锁定：
   在getInstance中做了两次null检查，确保只有第一次调用单例的时候才会同步，这样也是线程安全的，同时避免了每次都同步的性能损耗。
   如若把同步加到方法上 public static synchronized SingletonAA getInstance,则无论单例是否有值，都会同步，导致性能不佳
    为何要使用双重检查锁定呢？
考虑这样一种情况，就是有两个线程同时到达，即同时调用 getInstance() 方法，
此时由于 singleTon == null ，所以很明显，两个线程都可以通过第一重的 singleTon == null ，
进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 singleTon == null ，
而另外的一个线程则会在 lock 语句的外面等待。
而当第一个线程执行完 new  SingleTon（）语句后，便会退出锁定区域，此时，第二个线程便可以进入 lock 语句块，
此时，如果没有第二重 singleTon == null 的话，那么第二个线程还是可以调用 new  SingleTon （）语句，
这样第二个线程也会创建一个 SingleTon实例，这样也还是违背了单例模式的初衷的，
所以这里必须要使用双重检查锁定。
细心的朋友一定会发现，如果我去掉第一重 singleton == null ，程序还是可以在多线程下完好的运行的，
考虑在没有第一重 singleton == null 的情况下，
当有两个线程同时到达，此时，由于 lock 机制的存在，第一个线程会进入 lock 语句块，并且可以顺利执行 new SingleTon（），
当第一个线程退出 lock 语句块时， singleTon 这个静态变量已不为 null 了，所以当第二个线程进入 lock 时，
还是会被第二重 singleton == null 挡在外面，而无法执行 new Singleton（），
所以在没有第一重 singleton == null 的情况下，也是可以实现单例模式的？那么为什么需要第一重 singleton == null 呢？
这里就涉及一个性能问题了，因为对于单例模式的话，new SingleTon（）只需要执行一次就 OK 了，
而如果没有第一重 singleTon == null 的话，每一次有线程进入 getInstance（）时，均会执行锁定操作来实现线程同步，
这是非常耗费性能的，而如果我加上第一重 singleTon == null 的话，
那么就只有在第一次，也就是 singleTton ==null 成立时的情况下执行一次锁定以实现线程同步，
而以后的话，便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。

package com.jbx.singleton;

/**
 * 懒汉
 * 
 * @author Administrator
 * 
 */
public class SingletonA {
	private static SingletonA instance;

	private SingletonA() {
	}

	public static SingletonA getInstance() {
		if (instance == null) {
			instance = new SingletonA();
		}
		return instance;
	}
	
	public static void printInfo(){
		System.out.println(instance);
	}

	public static void main(String[] args) {
		SingletonA t1 = SingletonA.getInstance();
		t1.printInfo();
		
		SingletonA t2 = SingletonA.getInstance();
		t2.printInfo();
		
	}
}

普通懒汉模式

package com.jbx.singleton;

/**
 * 饿汉
 * 
 * @author Administrator
 * 
 */
public class SingletonB {
	private static SingletonB instance = new SingletonB();

	private SingletonB() {
	}

	public static SingletonB getInstance() {
		return instance;
	}
	
	public static void printInfo(){
		System.out.println(instance);
	}

	public static void main(String[] args) {
		SingletonB t1 = SingletonB.getInstance();
		t1.printInfo();
		
		SingletonB t2 = SingletonB.getInstance();
		t2.printInfo();
		
	}
}

饿汉模式


其他优秀文章：http://blog.csdn.net/licong20060541/article/details/48739103

关于指令重排序导致的单例问题，下面这篇文章讲述的非常好，特别容易理解，给作者点赞
https://mp.weixin.qq.com/s/zn8e7nKUPXq4G4CzyE7rPA