CAS:http://huangyunbin.iteye.com/blog/1942369
Future：http://blog.csdn.net/liulipuo/article/details/39029643
知识储备CAS
CAS基于冲突检测的无锁并发策略，性能也较高。CAS操作有3个操作数，内存值M，预期值E，新值U，如果M==E，则将内存值修改为B，否则啥都不做。
public class TestUnsafe { private static Unsafe unsafe; static{ try { //通过反射获取rt.jar下的Unsafe类 Field field = Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (Unsafe) field.get(null); } catch (Exception e) { System.out.println("Get Unsafe instance occur error"+ e); } } public static void main(String[] args) throws Exception { Class clazz = Target.class; Field[] fields = clazz.getDeclaredFields(); System.out.println("fieldName:fieldOffset"); for (Field f : fields) { // 获取属性偏移量，可以通过这个偏移量给属性设置 System.out.println(f.getName() + ":" + unsafe.objectFieldOffset(f)); } Target target = new Target(); Field intFiled = clazz.getDeclaredField("intParam") ; int a=(Integer)intFiled.get(target ) ; System.out.println("原始值是:"+a); //intParam的字段偏移是12 原始值是3 我们要改为10 System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10)); int b=(Integer)intFiled.get(target) ; System.out.println("改变之后的值是:"+b); //这个时候已经改为10了,所以会返回false System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10)); //false //判断target对象的偏移量24位置，即strParam，如果该变量值=null，则给strParam赋值5 System.out.println(unsafe.compareAndSwapObject(target, 24, null, "5")); //true } } class Target{ int intParam=3; long longParam; String strParam; String strParam2; } 测试结果：
FutureTask
futureTask的异步计算功能就不介绍了，主要分析源码，下图是futureTask的结构：
NEW 新建 0
COMPLETING 执行中 1NORMAL 正常 2EXCEPTIONAL 异常 3CANCELLED 取消 4INTERRUPTING 中断中 5INTERRUNPED 被中断 6state的状态变化可以有四种方式NEW->COMPLETING->NORMAL 正常完成的流程NEW->COMPLETING->EXCEPTIONAL 出现异常的流程NEW->CANCELED 被取消NEW->INTERRUNPING->INTERRRUNPTED 被中断创建FutureTask
public FutureTask(Callablecallable) { if (callable == null) throw new NullPointerException(); this.callable = callable; //state初始化NEW状态 this.state = NEW; // ensure visibility of callable }
run方法：
1 public void run() { 2 //如果当前state不是创建状态，且已经在运行。则直接return。 3 if (state != NEW || 4 !UNSAFE.compareAndSwapObject(this, runnerOffset, 5 null, Thread.currentThread())) 6 return; 7 //开始执行任务 8 try { 9 Callable c = callable;10 //创建状态，且callable不为空，开始执行调用call（）11 if (c != null && state == NEW) {12 V result;13 boolean ran;14 try {15 result = c.call();16 ran = true;17 } catch (Throwable ex) {18 result = null;19 ran = false;20 setException(ex);21 }22 //成功调用任务，执行set（）方法23 if (ran)24 set(result);25 }26 } finally {27 // runner must be non-null until state is settled to28 // prevent concurrent calls to run()29 //无论是否成功，都要把runner设置为null30 runner = null;31 // state must be re-read after nulling runner to prevent32 // leaked interrupts33 int s = state;34 if (s >= INTERRUPTING)35 handlePossibleCancellationInterrupt(s);36 }37 } 接下来看一下24行的set方法：
1 protected void set(V v) { 2 //CAS设置state NEW -> COMPLETING 3 if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { 4 //结果赋值outcome 5 outcome = v; 6 //CAS将state设置为NORMAL 7 UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state 8 //唤醒所有的等待线程，同时设置callable=null，调用done（），具体实现后面详细介绍 9 finishCompletion();10 }11 } cancel（）取消
1 public boolean cancel(boolean mayInterruptIfRunning) { 2 //如果state已经不是NEW 或者NEW不能设置成INTERRUPTING ， 则直接返回false 。 3 if (!(state == NEW && 4 UNSAFE.compareAndSwapInt(this, stateOffset, NEW, 5 mayInterruptIfRunning ? INTERRUPTING : CANCELLED))) 6 return false; 7 try { // in case call to interrupt throws exception 8 //如果是可中断 那么就 调用系统中断方法 然后把状态设置成INTERRUPTED 9 if (mayInterruptIfRunning) {10 try {11 Thread t = runner;12 if (t != null)13 //中断执行线程14 t.interrupt();15 } finally { // final state16 //最后设置state为INTERRUPTED17 UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);18 }19 }20 } finally {21 finishCompletion();22 }23 return true;24 } 再来看一下get操作：
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { if (unit == null) throw new NullPointerException(); int s = state;//如果还没完成，并且等待timeout也没有完成，则抛出超时异常 if (s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) throw new TimeoutException(); return report(s); } awaitDone（）操作来如何实现超时，已经完成但未超时，则结束等待返回结果，看具体代码：
private int awaitDone(boolean timed, long nanos) throws InterruptedException {//超时时间点 final long deadline = timed ? System.nanoTime() + nanos : 0L; WaitNode q = null; boolean queued = false;//循环执行 for (;;) {//中断处理 if (Thread.interrupted()) { removeWaiter(q); throw new InterruptedException(); } int s = state;//首先判断是否完成，如果完成，直接返回state结果 if (s > COMPLETING) { if (q != null) q.thread = null; return s; } else if (s == COMPLETING) // cannot time out yet Thread.yield();//未完成执行，则将当前线程（主线程）设置成等待节点并放入到等待队列中 else if (q == null) q = new WaitNode(); //将waiters设置成q的next节点，并替换，改操作只做一次，将main线程加入到队列中，只加一次 else if (!queued) queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);//如果启动了超时等待 else if (timed) {//计算剩余超时时间 nanos = deadline - System.nanoTime();//超时，移除队列中的等待线程，返回state，上层判断state，并报出超时异常 if (nanos <= 0L) { removeWaiter(q); return state; }//还未超时，则等待nanos时间，然而如果task执行接受，并不会一直等待，在run（）中的set（）中，会执行finishCompleted（），将对待队列线性唤醒，调用LockSupport.unpark()方法来唤醒等待线程 LockSupport.parkNanos(this, nanos); } else//未启用超时功能，在未完成callable，则无限期等待 LockSupport.park(this); } } 最后看一下finishCompletion()方法，调用callable，是如何唤醒main线程
private void finishCompletion() { // assert state > COMPLETING;//遍历等待队列 for (WaitNode q; (q = waiters) != null;) {//将waiters的头结点中线程设置null，即移除某个等待线程 if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { for (;;) { Thread t = q.thread;//如果等待线程不为null 调用LockSupport.unpark(t)唤醒，然后操作下一个等待线程 if (t != null) { q.thread = null; LockSupport.unpark(t); } WaitNode next = q.next; if (next == null) break; q.next = null; // unlink to help gc q = next; } break; } } done(); callable = null; // to reduce footprint } 至此，FutureTask的源码解析已经完成，接下来看一下开源对于异步处理的解决方案。
举一反三：
ChannelFuture
ListenableFuture