线程runnable和callable的区别

本文目录

• 线程runnable和callable的区别
• Java多线程几个方法的简单介绍
• Java的Runnable，Callable，Future，FutureTask有什么区别
• runnerable和callable的区别
• Java中Runnable和Thread以及Callable的区别
• java中runnable和callable的区别
• runnable和callable之间的区别
• java实现一个线程，用直接继承Thread类好，还是实现Runnable更好

线程runnable和callable的区别

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
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》
{
V call() throws Exception;
}
步骤1：创建实现Callable接口的类SomeCallable《Integer》（略）；
步骤2：创建一个类对象：
Callable《Integer》 oneCallable = new SomeCallable《Integer》();
步骤3：由Callable《Integer》创建一个FutureTask《Integer》对象：
FutureTask《Integer》 oneTask = new FutureTask《Integer》(oneCallable);
注释：FutureTask《Integer》是一个包装器，它通过接受Callable《Integer》来创建，它同时实现了Future和Runnable接口。
步骤4：由FutureTask《Integer》创建一个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《T》
{
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()方法

Java多线程几个方法的简单介绍

有三种：
(1)继承Thread类，重写run函数
创建：
class xx extends Thread{
public void run(){
Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源
}}
开启线程：
对象.start()//启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：
Thread t = new Thread(对象)//创建线程对象
t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同:
①Callable规定的方法是call()，而Runnable规定的方法是run().
②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
③call()方法可抛出异常，而run()方法是不能抛出异常的。
④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等
待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

Java的Runnable，Callable，Future，FutureTask有什么区别

Runnable ，Callable 都是线程接口 ，并且Callable 和Runnable挺相似 ，
但是 Runnable 是无法返回一个值 ，而Callable可以
Future 也是线程接口 ，和以上两的区别主要是提供了异步执行 ，并可以通过get返回结果，中途可以cancel
FutureTask实现了Future接口外还实现了Runnable接口，因此FutureTask也可以直接提交给Executor执行

runnerable和callable的区别

应是是runnable吧
runnable是形容词，意思是可追捕的，可猎取的
callable也是形容词，意思是可随时支取的，请求即付的，随时可偿还的

Java中Runnable和Thread以及Callable的区别

在java中，其实java中实现 多线程有三种方法，一种是继承Thread类；第二种是实现Runnable接口；第三种是实现Callable接口。
1，继承Thread
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
下面看例子：
package org.thread.demo;
class MyThread extends Thread{
private String name;
public MyThread(String name) {
super();
this.name = name;
}
public void run(){
for(int i=0;i《10;i++){
System.out.println(“线程开始：“+this.name+“,i=“+i);
}
}
}
package org.thread.demo;
public class ThreadDemo01 {
public static void main(String args) {
MyThread mt1=new MyThread(“线程a“);
MyThread mt2=new MyThread(“线程b“);
mt1.run();
mt2.run();
}
}
但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：
package org.thread.demo;
public class ThreadDemo01 {
public static void main(String args) {
MyThread mt1=new MyThread(“线程a“);
MyThread mt2=new MyThread(“线程b“);
mt1.start();
mt2.start();
}
};
这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）
2，Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口
public interface Runnable{
public void run();
}
例子：
package org.runnable.demo;
class MyThread implements Runnable{
private String name;
public MyThread(String name) {
this.name = name;
}
public void run(){
for(int i=0;i《100;i++){
System.out.println(“线程开始：“+this.name+“,i=“+i);
}
}
};
使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：
package org.runnable.demo;
import org.runnable.demo.MyThread;
public class ThreadDemo01 {
public static void main(String args) {
MyThread mt1=new MyThread(“线程a“);
MyThread mt2=new MyThread(“线程b“);
new Thread(mt1).start();
new Thread(mt2).start();
}
}
两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
1,避免点继承的局限，一个类可以继承多个接口。
2,适合于资源的共享
Runnable接口和Thread之间的联系：
public class Thread extends Object implements Runnable
发现Thread类也是Runnable接口的子类。
3，Callable接口
Callable 和 Runnable 的使用方法大同小异， 区别在于：
1.Callable 使用 call（） 方法， Runnable 使用 run() 方法
2.call() 可以返回值， 而 run()方法不能返回。
3.call() 可以抛出受检查的异常，比如ClassNotFoundException， 而run()不能抛出受检查的异常。
Callable示例如下：
Java代码
class TaskWithResult implements Callable《String》 {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
@Override
public String call() throws Exception {
return “result of TaskWithResult “ + id;
}
}
public class CallableTest {
public static void main(String args) throws InterruptedException,
ExecutionException {
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList《Future《String》》 results = new ArrayList《Future《String》》(); //Future 相当于是用来存放Executor执行的结果的一种容器
for (int i = 0; i 《 10; i++) {
results.add(exec.submit(new TaskWithResult(i)));
}
for (Future《String》 fs : results) {
if (fs.isDone()) {
System.out.println(fs.get());
} else {
System.out.println(“Future result is not yet complete“);
}
}
exec.shutdown();
}
}

java中runnable和callable的区别

1、意义区别：

Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；

Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

2、使用方法区别：

定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

举例说明：

package org.thread.demo;

class MyThread extends Thread{

private String name;

public MyThread(String name) {

super();

this.name = name;
}

public void run(){

for(int i=0;i《10;i++){

System.out.println(“线程开始：“+this.name+“,i=“+i);
}

runnable和callable之间的区别

是否 GetTickCount 在每台电脑上执行的速度不太一样，可能有些电脑取得的 Count 数的真实时间单位是 1ms
但有些可能多一点点或少一点点，如 1.001 ms 而每秒多 1ms 或是 .999 ms 每秒少 1ms 如果累积的一定程度，
与 BIOS Real Time Clock 的差异就变大

java实现一个线程，用直接继承Thread类好，还是实现Runnable更好

这两个没什么区别，看你个人喜好

thread内部源码里使用的也是实现runnable

callable与他俩区别事带个future类可以带返回值

要是实在要说的话，Java单继承多实现，如果你想实现多线程又想继承其他类的话，那你就用runnable,

没有绝对的好与不好，得看你实际需求的场景。

望采纳