Runnable、Callable、Future、LockSupport、happens-before

Callable与Runnable

先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：

public interface Runnable {
    public abstract void run();
}

由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。

Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()：

public interface Callable<V> {
    /*** Computes a result, or throws an exception if unable to do so.** @return computed result* @throws Exception if unable to compute a result*/V call() throws Exception;
}

可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

Future类位于java.util.concurrent包下，它是一个接口：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);boolean isCancelled();boolean isDone();V get() throws InterruptedException, ExecutionException;V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;
}

在Future接口中声明了5个方法，下面依次解释每个方法的作用：
cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone方法表示任务是否已经完成，若任务完成，则返回true；
get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
也就是说Future提供了三种功能：

1）判断任务是否完成；

2）能够中断任务；

3）能够获取任务执行结果。

happens-before例子

consider this program:

volatile int state;  
Integer   result;
void succeed(Integer result)if(state==PENDING)              vr0this.result = result;        w1state = DONE;               vw1Integer peekResult()if(state==DONE)                 vr2 return result;               r2return null;

If volatile read vr2 sees DONE, it means it happens after volatile write vw1. So we have happens-before relationships: w1 -> vw1 -> vr2 -> r2. Therefore write w1 is visible to read r2.

However succeed() isn’t thread safe, since vr0 and vw1 are not atomic. If we use CAS

void succeed(Integer result)if( compareAndSet(state, PENDING, DONE) )      vr0+vw0this.result = result;                       w1

it fixes the atomicity issue. However, now w1 isn’t necessarily visible to r2. The memory barrier effect of CAS is kind of like

void succeed(Integer result)if(state==PENDING)         vr0state=DONE;            vw0this.result = result;   w1

We have here vw0 -> vr2 -> r2, but w1 is not on the chain, there is no w1 -> r2

We must do the volatile write state=DONE after w1 to establish the happens-before chain.

void succeed(Integer result)if(state==PENDING)            vr0state=TMP;                vw0this.result = result;      w1state=DONE;               vw1

or in CAS

void succeed(Integer result)if( compareAndSet(state, PENDING, TMP) )       vr0+vw0this.result = result;                       w1state=DONE;                                vw1

LockSupport

public static void park(Object blocker); // 暂停当前线程
public static void parkNanos(Object blocker, long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(Object blocker, long deadline); // 暂停当前线程，直到某个时间
public static void park(); // 无期限暂停当前线程
public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(long deadline); // 暂停当前线程，直到某个时间
public static void unpark(Thread thread); // 恢复当前线程
public static Object getBlocker(Thread t);

park()和unpark(Thread thread) 是一一相对的，unpark类比许可数，park类比需求，unpark可以先堆积，然后一次次park消费。
Thread.currentThread().interrupt();方法打断了一个线程那么所有的park都失效了，无论park是在打断前或打断后。并且中断的时候park不会抛出异常，需要在park之后自行判断中断状态。