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

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

首先将它们分个类：

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

首先 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 类位于 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 多线程关键词的整顿，不至于一团乱麻。

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

对于 Ranable 和 Callable

对于 Future 和 FutureTask

Just My Socks（注册教程内含优惠码）

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

对于 Ranable 和 Callable

对于 Future 和 FutureTask

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）