Runnable 和Callable的实现与区别，应用场景
大家好，又见面了，我是你们的朋友全栈君。
Java 提供了三种创建线程的方法
1：通过实现Runnable接口 2：通过继承Thread接口 3：通过Callable和Future创建线程
- 相同点 都是接口 都可以编写多线程程序 都采用Thread.start()启动线程
- 不同点 (1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。 (2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得 (3)call方法可以抛出异常，run方法不可以 (4)运行Callable任务可以拿到一个Future对象，c表示异步计算的结果。
注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
线程的创建如下
1、通过实现Runnable接口来创建Thread线程：
步骤1：创建实现Runnable接口的类：
class SomeRunnable implements Runnable { public void run() { //do something here } }
步骤2：创建一个类对象：
Runnable oneRunnable = new SomeRunnable();步骤3：由Runnable创建一个Thread对象：
Thread oneThread = new Thread(oneRunnable);步骤4：启动线程：
oneThread.start();至此，一个线程就创建完成了。
注释：线程的执行流程很简单，当执行代码oneThread.start();时，就会执行oneRunnable对象中的void run();方法，
该方法执行完成后，线程就消亡了。
2、与方法1类似，通过实现Callable接口来创建Thread线程：其中，Callable接口（也只有一个方法）定义如下：
public interface Callable { V call() throws Exception; } 步骤1：创建实现Callable接口的类SomeCallable（略）；
步骤2：创建一个类对象：
Callable<Integer> oneCallable = new SomeCallable<Integer>();步骤3：由Callable创建一个FutureTask对象：
FutureTask<Integer> oneTask = new FutureTask<Integer>(oneCallable);
注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。步骤4：由FutureTask创建一个Thread对象：
Thread oneThread = new Thread(oneTask);步骤5：启动线程：
oneThread.start();至此，一个线程就创建完成了。
3、通过继承Thread类来创建一个线程：
步骤1：定义一个继承Thread类的子类：
class SomeThead extends Thraad { public void run() { //do something here } }
步骤2：构造子类的一个对象：
SomeThread oneThread = new SomeThread();步骤3：启动线程：
oneThread.start();至此，一个线程就创建完成了。
注释：这种创建线程的方法不够好，主要是因为其涉及运行机制问题，影响程序性能。4、通过线程池来创建线程：
步骤1：创建线程池：
ExecutorService pool = Executors.newCachedThreadPool();步骤2：通过Runnable对象或Callable对象将任务提交给ExecutorService对象：
Future<Integer> submit(Callable<Integer> task);
注释：Future是一个接口，它的定义如下：public interface Future { V get() throws …; V get(long timeout, TimeUnit unit) throws …; void cancle(boolean mayInterrupt); boolean isCancelled(); boolean isDone(); }
至此，一个线程就创建完成了。
注释：线程池需调用shutdown();方法来关闭线程。5、通过事件分配线程直接使用程序中的原有线程：
使用方法： 直接调用EventQueue类的静态方法invokeLater()：
EventQueue.invokeLater(oneRunnable);
注释：调用EventQueue.invokeLater(oneRunnable);会直接执行oneRunnable对象中的run()方法Callable使用
/**
* CallableImpl 简要描述
* <p> TODO:描述该类职责 </p>
*
* @author ckmike
* @version 1.0
* @date 18-12-6 下午8:53
* @copyright ckmike
**/
public class CallableImpl implements Callable<String> {
private String accept;
public CallableImpl(String accept) {
this.accept = accept;
}
@Override
public String call() throws Exception {
// 休眠
TimeUnit.SECONDS.sleep(3);
return this.accept;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<String> callable = new CallableImpl("my callable test!");
FutureTask<String> task = new FutureTask<>(callable);
long beginTime = System.currentTimeMillis();
// 创建线程
new Thread(task).start();
// 调用get()阻塞主线程，反之，线程不会阻塞
String result = task.get();
long endTime = System.currentTimeMillis();
System.out.println("hello : " + result);
System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
}
}Runnable使用
/**
* RunnableImpl 简要描述
* <p> TODO:描述该类职责 </p>
*
* @author ckmike
* @version 1.0
* @date 18-12-6 下午9:03
* @copyright ckmike
**/
public class RunnableImpl implements Runnable {
public RunnableImpl(String accept) {
this.accept = accept;
}
private String accept;
@Override
public void run() {
// 线程阻塞 1 秒，此时有异常产生，只能在方法内部消化，无法上抛
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 最终处理结果无法返回
System.out.println("hello : " + this.accept);
}
public static void main(String[] args) {
Runnable runnable = new RunnableImpl("my runable test!");
long beginTime = System.currentTimeMillis();
new Thread(runnable).start();
long endTime = System.currentTimeMillis();
System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
}
}发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/127344.html原文链接：https://javaforall.cn
腾讯云开发者
