Java多线程编程

Callable

Runnable封装了一个异步运行的任务，可以把它想象成为一个没有参数和返回值的异步方法。Callable和Runnable类似，但是有返回值，Callable接口是一个参数化的类型，只有一个方法call

public interface Callable<V>
{
    V call() throws Exception
}

Future

Future可以保存异步计算的结果，可以启动一个计算，将Future对象交给某个线程，Future对象的所有者在结果计算好之后就可以获得它
Future接口具有下面的方法:

public interface Future<V>
{
    V get() throws...;
    V get(long timeout, TimeUnit unit) throws...; 
    void cancel(boolean mayInterrupt);
    boolean isCancelled();
    boolean isDone();
}

FutureTask包装器

可以将Callable转换成Future和Runnable，它实现了二者的接口

Callable<Integer> myComputation = ...;
FutureTask<Integer> task = new FutureTask<Integer>(myComputation);
Thread thread = new Thread(task);
thread.start();
...
Integer result = task.get(); // It `s future

调用get()方法会发生阻塞，直到结果可以获得为止。

相关事例

在Java多线程处理任务过程中，由于每一个线程处理完自身任务之后，需要将数据传出来，然后再经过整合，完成这个业务功能。
鉴于线程自身运行完毕阶段无法返回数据，可以通过Future对象交给线程，之后通过Future对象获取到计算结果
通过FutureTask包装器将Callable转换成Future和Runnable；
比如

package future;
import java.util.concurrent.*;

public class FutureTaskCount {
    // 定义4个计算线程
    Callable<Integer> calculate1 = new Callable<Integer>() {
        private int count = 0;
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 4; i++) {
                count++;
                System.out.println("此时线程1正在运行 当前count: " + count);
                Thread.sleep(1000);
            }
            return count;
        }
    };

    Callable<Integer> calculate2 = new Callable<Integer>() {
        private int count = 0;
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 4; i++) {
                count++;
                System.out.println("此时线程2正在运行 当前count: " + count);
                Thread.sleep(1000);
            }
            return count;
        }
    };

    Callable<Integer> calculate3 = new Callable<Integer>() {
        private int count = 0;
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 4; i++) {
                count++;
                System.out.println("此时线程3正在运行 当前count: " + count);
                Thread.sleep(1000);
            }
            return count;
        }
    };

    Callable<Integer> calculate4 = new Callable<Integer>() {
        private int count = 0;
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 4; i++) {
                count++;
                System.out.println("此时线程4正在运行 当前count: " + count);
                Thread.sleep(1000);
            }
            return count;
        }
    };

    public static void main(String[] args) {
        FutureTaskCount futureTaskCount = new FutureTaskCount();
        // 获取线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        FutureTask calculate1 = new FutureTask<Integer>(futureTaskCount.calculate1);
        FutureTask calculate2 = new FutureTask<Integer>(futureTaskCount.calculate2);
        FutureTask calculate3 = new FutureTask<Integer>(futureTaskCount.calculate3);
        FutureTask calculate4 = new FutureTask<Integer>(futureTaskCount.calculate4);

        executorService.submit(calculate1);
        executorService.submit(calculate2);
        executorService.submit(calculate3);
        executorService.submit(calculate4);
        try {
            System.out.println(calculate1.get());
            System.out.println(calculate2.get());
            System.out.println(calculate3.get());
            System.out.println(calculate4.get());
            System.out.println("所有线程计算均执行完毕");
        } catch (InterruptedException exception) {
            exception.printStackTrace();
        } catch (ExecutionException exception) {
            exception.printStackTrace();
        }

    }
}

当所有线程的计算均完毕时候，才会打印出 "所有线程计算均执行完毕"，也就是调用get()方法会发生阻塞，直到结果可以获得为止。executorService.submit的调用，相当于启动线程操作了，以上代码中需要将call()方法overwrite。此时，每个线程可以独立运行任务。最后直接调用get()获取每个线程计算结果

执行器(Executor)

执行器有许多方法来构建线程池，比如newCachedThread方法构建了一个线程池，对于每个任务，如果有空闲线程可用，立即让它执行任务，如果没有可用的线程，则创建一个新线程，那么把得不到服务的任务放置到队列中。当其他任务完成以后再运行它们。