Java 的Runnable和Callable的区别

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

1.1使用Runnble接口创建线程


public class RunnableTest implements Runnable {@Overridepublic void run() {System.out.println("this thread name is:"+Thread.currentThread().getName());}public static void main(String[] args) {System.out.println(Thread.currentThread().getName());RunnableTest r = new RunnableTest();Thread t = new Thread(r);t.start();}
}

或者使用匿名类实现:

Thread thread =new Thread(new Runnable() {public void run() {// TODO Auto-generated method stubSystem.out.println("匿名类实现线程");}

使用1.2 使用 Executors 创建线程

package com.asiainfo.proxydemo;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadExecutorService {//设置线程的数量private  static int POOL_NUM=10;/*** @param args*/public static void main(String[] args) {
//      ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
//      ExecutorService newFixedThreadPool = Executors.newCachedThreadPool();
//      ExecutorService newFixedThreadPool = Executors.newScheduledThreadPool(3);
//      ExecutorService newFixedThreadPool = Executors.newSingleThreadExecutor();ExecutorService newFixedThreadPool = Executors.newSingleThreadScheduledExecutor();for (int i = 0; i < POOL_NUM; i++) {RunnableImpl runnableImpl = new RunnableImpl("thread--"+i);newFixedThreadPool.execute(runnableImpl);}newFixedThreadPool.shutdown();}}
class RunnableImpl implements Runnable{private String name;public RunnableImpl(String name) {super();// TODO Auto-generated constructor stubthis.name=name;}public void run() {// TODO Auto-generated method stubSystem.out.println("hello ExecutorService"+name);}}

2.1 使用Callable 创建线程

package com.asiainfo.proxydemo;import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;public class ThreadCallable {/*** @param args*/
public static void main(String[] args) {Tickets<java.lang.Object> tickets = new Tickets<Object>();FutureTask<java.lang.Object> futureTask = new FutureTask<Object>(tickets);Thread thread = new Thread(futureTask);System.out.println(Thread.currentThread().getName());thread.start();
}
}
class Tickets<Object> implements Callable<Object>{/* (non-Javadoc)* @see java.util.concurrent.Callable#call()*/public Object call() throws Exception {// TODO Auto-generated method stubSystem.out.println(Thread.currentThread().getName()+"通过实现Callable接口通过FutureTask包装器来实现线程");return null;}}

2.2 使用 Executors 结合Callable 创建多线程

在Java5之后，任务分两类：一类是实现了Runnable接口的类，一类是实现了Callable接口的类。两者都可以被ExecutorService执行，但是 Runnable任务没有返回值，而Callable任务有返回值。并且Callable的call（）方法只能通过ExecutorService的 submit（Callable<T> task）方法来执行，并且返回一个 <T> Future<T>，是表示任务等待完成的 Future.

　　public interface Callable<V>返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。

　　Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。

　　Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。

　　Callable中的call（）方法类似Runnable的run（）方法，就是前者有返回值，后者没有。

　　当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。

　　同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null.

package com.asiainfo.proxydemo;import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;public class ThreadCallableDemo2 {public static void main(String[] args) {ExecutorService executorService = Executors.newCachedThreadPool();List<Future<String>> resultList = new ArrayList<Future<String>>();// 创建10个任务并执行for (int i = 0; i < 10; i++) {// 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中Future<String> future = executorService.submit(new TaskWithResult(i));// 将任务执行结果存储到List中resultList.add(future);}// 遍历任务的结果for (Future<String> fs : resultList) {try {System.out.println(fs.get()); // 打印各个线程（任务）执行的结果} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();} finally {// 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。executorService.shutdown();}}}
}class TaskWithResult implements Callable<String> {private int id;public TaskWithResult(int id) {this.id = id;}public String call() throws Exception {System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());// 一个模拟耗时的操作for (int i = 999999; i > 0; i--);return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();}
}

参考：https://blog.csdn.net/w2393040183/article/details/52177572

http://murielily.blog.163.com/blog/static/134260649201131215237637/

Java 的Runnable和Callable的区别相关推荐

java中Runnable和Callable的区别
文章目录运行机制返回值的不同 Exception处理 java中Runnable和Callable的区别在java的多线程开发中Runnable一直以来都是多线程的核心,而Callable是ja ...
Runnable和Callable的区别:
Runnable和Callable的区别: (1)Runnable是自从java1.1就有了,而Callable是1.5之后才加上去的(2)Callable规定的方法是call(),Runnable规 ...
Runnable 和 Callable 的区别
区别两个都是接口,但是 Runnable 方法中 run() 没有声明异常且没有返回值,而 Callable 中 call() 声明了异常且有返回值:(意味着使用 Runnable 需要自己处理异常 ...
Java中Runnable和Thread的区别
2019独角兽企业重金招聘Python工程师标准>>> 在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口:Thread类是在java.la ...
再谈 Java中Runnable和Thread的区别
在面试中老有面试官问这个问题,个人觉得这个问题问的没有技术,一个死记硬背就能回答的很好.但是更深的回答是什么了,那就是直接回答源码吧. thread类实现了runnable 接口 ,Runnable就 ...
剑指offer之Runnable和Callable的区别
Runnable Runnable接口非常简单,就定义了一个方法run(), 实现Runnable接口的run方法就可以实现多线程 // 函数式接口 @FunctionalInterface publ ...
Runnable 与 Callable 的区别
1. 类结构 Runnable: @FunctionalInterface public interface Runnable {public abstract void run(); } Calla ...
一次搞懂 Runnable、Callable、Future、FutureTask，不懂不要钱！
点击上方蓝色"方志朋",选择"设为星标" 回复"666"获取独家整理的学习资料! 一般创建线程只有两种方式,一种是继承Thread,一种是实 ...
Java中的Runnable、Callable、Future、FutureTask的区别与示例
原文地址:http://blog.csdn.net/bboyfeiyu/article/details/24851847 --------------------------------------- ...

Java 的Runnable和Callable的区别

Java 的Runnable和Callable的区别相关推荐

最新文章

热门文章