并发编程-Future+callable+FutureTask 闭锁机制

项目中经常有些任务需要异步(提交到线程池中)去执行，而主线程往往需要知道异步执行产生的结果，这时我们要怎么做呢？用runnable是无法实现的，我们需要用callable实现。

public class FutureTask<V> implements RunnableFuture<V> 

public interface RunnableFuture<V> extends Runnable, Future<V> { /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */ 
    void run(); 
}

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

public interface Future<V> { /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, has already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when {@code cancel} is called,
     * this task should never run.  If the task has already started,
     * then the {@code mayInterruptIfRunning} parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     */ 
    boolean cancel(boolean mayInterruptIfRunning); /**
     * Returns {@code true} if this task was cancelled before it completed
     * normally.
     */ 
    boolean isCancelled();//如果任务被取消，返回true /**
     * Returns {@code true} if this task completed.
     */ 
    boolean isDone();//如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。 /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     */ 
    V get() throws InterruptedException, ExecutionException; //获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。 /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     */ 
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; 
    }

//构造函数1 
public FutureTask(Runnable runnable, V result) { 
    this.callable = Executors.callable(runnable, result); 
    this.state = NEW; // ensure visibility of callable 
} 
//构造函数2
public FutureTask(Callable<V> callable) { 
    if (callable == null) 
        throw new NullPointerException(); 
    this.callable = callable;
     this.state = NEW; // ensure visibility of callable 
}

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; 
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
    // 创建一个Future对象，并把Callable的实现传给构造函数
    private static final FutureTask<Integer> future = new FutureTask<Integer>(new CallableTest());

    public static void main(String[] args) {
        // 创建一个线程
        final Thread thread = new Thread(future);
        // 启动线程
        thread.start();
        try {
            Thread.sleep(1000);
            System.out.println("Main thread is running");
            // 获取计算结果，会阻塞知道计算完毕
            System.out.println("get the sub thread compute result : " + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("main thread is end");
    }

    // 实现Callable接口，耗时操作
    static class CallableTest implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int ret = 0;
            Thread.sleep(1000);
            System.out.println("sub thread is computing");
            for (int i = 0; i < 1000; i++) {
                ret += i;
            }
            System.out.println("sub thread is finish compute");
            return ret;
        }
    }
}

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

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
    public static void main(String[] args) {
        // 返回一个线程池，通常都和这种线程宽架搭配
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        System.out.println("Main thread is running");
        // 提交给线程，返回一个Future类，并执行
        Future<Integer> future = threadPool.submit(new CallableTest());
        try {
            Thread.sleep(1000);
            // 获取计算结果，会阻塞知道计算完毕
            System.out.println("get the sub thread compute result : " + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("main thread is end");
    }

    // 实现Callable接口，耗时操作
    static class CallableTest implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int ret = 0;
            Thread.sleep(1000);
            System.out.println("sub thread is computing");
            for (int i = 0; i < 1000; i++) {
                ret += i;
            }
            System.out.println("sub thread is finish compute");
            return ret;
        }
    }
}