关于java:Java中实现多线程关键词整理

Java 中的 Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor 在这里对这些关键词，以及它们的用法做一个总结。

首先将它们分个类：

• Runable,Callable
• Future,FutureTask
• ExecutorService,Executor,Excutors,ThreadPoolExcetor

对于 Ranable 和 Callable

首先 Java 中创立线程的办法有三种：

• 继承 Thread 类，笼罩 run 办法
• 实现 Runable 接口，实现 run 办法
• 实现 Callable 接口，实现 run 办法

三种实现的优缺点：

• 继承 Thread，单继承的缘故，不能再继承其余类，获取以后线程 this
• 实现 Runable 接口，没有返回值，获取以后线程 Thread.currentThread()
• 实现 Callable 接口，可通过 Future.get() 获取返回值，获取以后线程 Thread.currentThread()

继承 Thread，两个步骤：

class DemoThread extends Thread {
    @Override
    public void run() {super.run();
        // Perform time-consuming operation...
    }
}// 退出 Java 开发交换君样：756584822 一起吹水聊天
DemoThread t = new DemoThread();
t.start();

继承 Thread 类，笼罩 run() 办法。
创立线程对象并用 start() 办法启动线程。
实现 Runable，个别应用如下：

new Thread(new Runnable() {
    @Override
    public void run() {// do something}
}).start();

为了简略。
以上两种形式获取线程执行的后果相当麻烦，不能间接获取。JDK1.5 减少了 Callable, Callable 的 call() 办法能够返回值和抛出异样。Callable 能够返回装载有计算结果的 Future 对象。
Callable 的源码：

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

Callable 的根本应用办法：

FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        // do something
        return null;
    }
});
Thread thread = new Thread(futureTask);
thread.start();
Integer result = futureTask.get();

运行 Callable 工作能够拿到一个 Future 对象，通过 Future 的 get() 办法拿到线程执行的返回值。那么 …Future，FutureTask 区别是什么，怎么应用？
->next()

对于 Future 和 FutureTask

为了获取线程的执行后果，引入了 Future 的 FutureTask，那么他们是什么关系，如何应用？
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;
}// 退出 Java 开发交换君样：756584822 一起吹水聊天 

Future 定义了 5 个办法：

• boolean cancel(boolean
  mayInterruptIfRunning)：试图勾销对此工作的执行。如果工作已实现、或已勾销，或者因为某些其余起因而无奈勾销，则此尝试将失败。当调用
  cancel() 时，如果调用胜利，而此工作尚未启动，则此工作将永不运行。如果工作曾经启动，则
  mayInterruptIfRunning 参数确定是否应该以试图进行工作的形式来中断执行此工作的线程。此办法返回后，对
  isDone() 的后续调用将始终返回 true。如果此办法返回 true，则对 isCancelled() 的后续调用将始终返回
  true。
• boolean isCancelled()：如果在工作失常实现前将其勾销，则返回 true。
• boolean isDone()：如果工作已实现，则返回 true。
  可能因为失常终止、异样或勾销而实现，在所有这些状况中，此办法都将返回 true。
• V get()throws
  InterruptedException,ExecutionException：如有必要，期待计算实现，而后获取其后果。
• V get(long timeout,TimeUnit unit) throws InterruptedException,
  ExecutionException, TimeoutException：
  如有必要，最多期待为使计算实现所给定的工夫之后，获取其后果（如果后果可用）。

总的来说 Future 提供了三种性能：

• 判断工作是否实现；可能中断工作；
• 可能获取工作执行后果。

重点：
RunnableFuture 继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。
FutureTask 的实现：

public class FutureTask<V> implements RunnableFuture<V>

RunnableFuture 接口的实现：

public interface RunnableFuture<V> extends Runnable, Future<V> {void run();
}

FutureTask 是 Future 接口的一个惟一实现类。
除了能够用 Thread 包装 FutureTask 外，还有另一种应用办法：

ExecutorService executor = Executors.newCachedThreadPool();
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        // do something
        return null;
    }// 退出 Java 开发交换君样：756584822 一起吹水聊天
});
executor.submit(futureTask);
Integer result = futureTask.get();

这里用到了 Executor 框架。
->next();

对于 ExecutorService,Executor,Excutors,ThreadPoolExcetor

Executor 框架在 Java 5 中被引入，Executor 框架是一个依据一组执行策略调用、调度、执行和管制的异步工作的框架。
在说 Executor 框架之前咱们须要引入一个新的概念——线程池（ThreadPoolExecutor）：

public ThreadPoolExecutor(intcorePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler)
// 退出 Java 开发交换君样：756584822 一起吹水聊天 

ThreadPoolExecutor 是 Executors 类的底层实现。
在 JDK 帮忙文档中，有如此一段话：

“强烈建议程序员应用较为不便的 Executors 工厂办法 Executors.newCachedThreadPool()（无界限程池，能够进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）和 Executors.newSingleThreadExecutor()（单个后盾线程），它们均为大多数应用场景预约义了设置。”

那么 ExecutorService,Excetor,Excutors 都是什么？
Excetor 是一个形象层面的外围接口：

public interface Executor {void execute(Runnable command);
}

ExecutorService 接口 对 Executor 接口进行了扩大，提供了返回 Future 对象，终止，敞开线程池等办法。

public interface ExecutorService extends Executor {void shutdown();
    // 退出 Java 开发交换君样：756584822 一起吹水聊天
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
}

Executors 是一个工具类，相似于 Collections。提供工厂办法来创立不同类型的线程池，比方 FixedThreadPool 或 CachedThreadPool。

public class Executors {public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
        }
        
     public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        }
}

以上是对 Java 多线程关键词的整顿，不至于一团乱麻。