线程runnable和callable的区别

线程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,

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

望采纳


推荐阅读