单例设计模式

单例 保证一个类仅有一个实例 并提供一个访问它的全局访问点。

懒汉式（饿汉式涉及到JVM性能问题,本文不介绍）
调用：SingleTon.getInstance().method();

实现一：
//优点：延迟加载,适合单线程操作
//缺点： 线程不安全，在多线程中很容易出现不同步的情况，如在数据库对象进行的频繁读写操作时。

public class SingleTonDemo {

	//私有化静态实例 实现懒加载
	private static SingleTonDemo instance=null;
	
	//无参构造
	private SingleTonDemo(){}
	
	//静态方法创建实例
	public static SingleTonDemo getInstance() {
		if(instance==null) {
			instance=new SingleTonDemo();
		}
		return instance;
	}
}

实现二：
//同步synchronized改造，推荐使用同步代码块，不建议使用同步类、同步方法（相对更耗性能）

public class SynSingleTon {
	
	//私有化静态实例 实现懒加载
	private static SynSingleTon instance=null;
	
	//无参构造
	private SynSingleTon(){}
	
	//静态方法创建实例
	public static SynSingleTon getInstance() {
		if(instance==null) {
			synchronized(SingleTonDemo.class) {
				if(instance==null) {
					instance=new SynSingleTon();
				}
			}
		}
		return instance;
	}
}

实现三：
//内部类实现 线程安全（java中class加载时互斥的），也减少了内存消耗

public class InnerSingleTon {

	//懒加载，减少内存开销
	private static class InnerSingleTonHolder{
		private static InnerSingleTon instance=new InnerSingleTon();
	}
	
	//无参构造
	private InnerSingleTon(){}
	
	public static InnerSingleTon getInstance() {
		return InnerSingleTonHolder.instance;
	}
}

实现四：
CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
优点：用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。
缺点：CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。

public class CasSingleton {
	
	//AtomicReference
	private static final AtomicReference<CasSingleton> ISNTANCE=new AtomicReference<CasSingleton>();
	
	//无参构造
	private CasSingleton(){}
    
    public static CasSingleton getInstance() {
    	for (;;) {
    		CasSingleton casSingleton = ISNTANCE.get();
    		if(ISNTANCE.compareAndSet(null, casSingleton)) {
    			casSingleton=new CasSingleton();
    		}
    		return casSingleton;
		}
    }
    
    public static void method() {
    	System.out.println("---method---");
    }
}

（本文展示的是处理过后的基本实现代码；水平有限，供交流分享，如有错误，还请指教，谢谢~~）