java不一样的单例模式

public class AtomicSingleton
 {
	private static AtomicReference<AtomicSingleton> INSTANCE 
	          = new AtomicReference<>();
	private AtomicSingleton() {}
	
	public static AtomicSingleton getInstace(){
		AtomicSingleton current = INSTANCE.get();
		for (;;) {
			if(current != null){
				return current;
			}
			current = new AtomicSingleton();
			
			if(INSTANCE.compareAndSet(null, current))
			{
				return current;
			}
			
		}
	}
}

ASimpleCache源码中也用到了原子变量类：

https://github.com/yangfuhai/ASimpleCache/blob/master/source/src/org/afinal/simplecache/ACache.java

public class ACacheManager{

private final AtomicLong cacheSize;

private final AtomicInteger cacheCount;

private finallongsizeLimit;

private final intcountLimit;

private final Map lastUsageDates=Collections

.synchronizedMap(newHashMap());

protectedFilecacheDir;

private ACacheManager(FilecacheDir,longsizeLimit,intcountLimit) {

this.cacheDir=cacheDir;

this.sizeLimit=sizeLimit;

this.countLimit=countLimit;

cacheSize=newAtomicLong();

cacheCount=newAtomicInteger();

calculateCacheSizeAndCacheCount();

}

.....}

AtomicReference是作用是对"对象"进行原子操作。通过源码可以看出，它是通过"volatile"和"Unsafe提供的CAS（比较与交换，Compare and swap,是一种有名的无锁算法函数）实现原子操作。

CAS

Java 理论与实践: 非阻塞算法简介：

https://www.ibm.com/developerworks/cn/java/j-jtp04186

current是volatile类型。这保证了：当某线程修改value的值时，其他线程看到的value值都是最新的，即修改之后的volatile的值。

通过CAS设置value。这保证了：当某线程池通过CAS函数(如compareAndSet函数)设置value时，它的操作是原子的，即线程在操作value时不会被中断。CAS是一种无阻塞的锁,采用不断比较设值的方式来避免并发问题,不会有锁的等待和上下文切换问题,性能消耗较小。

如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。

这种方式既能够保证延迟加载又能保证原子性及实例的唯一性，代码也相对比较简洁。

通过并发的学习与使用，线程的阻塞和上下文的切换会带来一定的性能开销，尤其在高并发的环境下。

而原子变量可以避免优先级倒置和死锁等危险，竞争比较便宜，协调发生在更细的粒度级别，允许更高程度的并行机制等等。

可以选择这种单例模式，不论从效率和并发方面都高于饿汉试和单汉试

枚举单例也是不错的选择，但是枚举所开销的内存比其它的单例大