Java中Runnable和Thread的区别

发布网友 发布时间：2022-04-19 23:11

我来回答

共15个回答

热心网友 时间：2022-04-10 01:58

区别：Thread是类，而Runnable是接口。
抽象类和接口的区别如下：
① 在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现接口则要实现里面的全部方法。
②在接口中无成员变量，而抽象类中可有成员变量。
在Java中引进接口主要是为了解决多继承的问题。
实现多线程主要继承Thread 类和实现Runnable接口。

热心网友 时间：2022-04-10 03:16

1、在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；

Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类。这也是此方法的局限。

2、继承Thread实现的模式是  定义多个线程,各自完成各自的任务.

实现Runnable实现的模式是  定义多个线程,实现一个任务.

3、在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

避免点继承的局限，一个类可以继承多个接口。

适合于资源的共享

热心网友 时间：2022-04-10 04:51

thread是类,runnable是接口,都可以是多线程,

但是在创建多线程的方法中我们可以有2种方法

class MyThread extends Thread{
public void run(){
System.out.println("this is thread");
}
}

class MyRunnable implements Runnable{
    public void run(){
        System.out.println("this is runnable");
    }
}

在实际使用中我们推荐使用runnable方法

因为如果使用thread的话就不能继承其他类(ps:一个类只能继承一个父类)

但是runnable就不同(一个类可以实现多个接口)

以上是我的理解

热心网友 时间：2022-04-10 06:42

以下是一篇简单的介绍，我翻过来给你看下。

在 Java 语言中，我们都知道有俩种方式可以创建一个线程。

继承 Thread 类 。

实现 Runnable 接口 。

代码如下：

//new Thread(new MyWork()).start();
public class MyWork implements Runnable {
    public void run() {
        // your work here ...
    }
}
//Thread.start();
public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        // your work here ...
    }
}

这俩的区别讨论很多。我总结了大概有以下几点。

实现 Runnable 大多数情况下是比继承 Thread 更好的方法。

Java 只支持单继承，所以你继承了 Thread 的话，其他的类你就不能继承了。

 如果实现 Runnable 接口，多线程可以直接将你的工作并发处理（直接使用 start）。而继承 Thread 不能直接进行多线程工作，你得为你的每一部分工作都定义一个线程。

其他的一些API，接口都是 Runnable 类型的。比如 Java 内置的线程池 API ExcutorService 等。

其实 Thread 只是实现 Runnable 接口，并增加了一些常用方法而已。不信你看源码。

public
class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }
    ...

热心网友 时间：2022-04-10 08:50

线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,
我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样.

你简单的调用run方法是没有这样效果的,所以你必须调用Thread类的start方法来启动你的线程.所以你启动线程有两种方法
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动

这两种方法都必须实现RUN方法,这样线程起动的时候,线程管理器好去调用你的RUN方法.

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享

热心网友 时间：2022-04-10 11:15

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；

Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

Java由四方面组成：

Java编程语言，即语法。

Java文件格式，即各种文件夹、文件的后缀。

Java虚拟机(JVM)，即处理*.class文件的解释器。

Java应用程序接口(Java API)。

热心网友 时间：2022-04-10 13:56

我尽最大努力把问题解释清楚，不足之处，请赐教！
首先，
之所以出现线程，就是为了更好的利用CPU，让她更加“精明”的干活。

通过调用Thread类的start()方法来启动一个线程，
这时此线程是处于就绪状态，
并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，
这里方法run()称为线程体，
它包含了要执行的这个线程的内容，
Run方法运行结束，
此线程终止，
而CPU再运行其它线程，

而如果直接用Run方法，
这只是调用一个方法而已，
程序中依然只有主线程--这一个线程，
其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

记住：线程就是为了更好地利用CPU，
提高程序运行速率的！

public class TestThread1{
public static void main(String[] args){
Runner1 r=new Runner1();
//r.run();//这是方法调用，而不是开启一个线程
Thread t=new Thread(r);//调用了Thread(Runnable target)方法。且父类对象变量指向子类对象。
t.start();

for(int i=0;i<100;i++){
System.out.println("进入Main Thread运行状态");
System.out.println(i);
}
}
}
class Runner1 implements Runnable{ //实现了这个接口，jdk就知道这个类是一个线程
public void run(){

for(int i=0;i<100;i++){
System.out.println("进入Runner1运行状态");
System.out.println(i);
}
}
}

如果还看不明白的话，
我QQ：516258551
咱们再在QQ上讨论

不知答案能否让你满意

热心网友 时间：2022-04-10 16:54

Java实现线程的两种方法：1继承Thread类。2 实现Runnable接口实现多线程。我觉得比较大的区别：是两个不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。在现实应用中一般我们用实现Runnable接口来实现多线程。

热心网友 时间：2022-04-10 20:09

Thread需要继承,Rnnable需要实现该接口 都可以用来创建线程,但是通过继续Thread方法创建线程相当于你在商场买了一台别人已经组装好的电脑,可以拿来直接用,而实现Runble接口创建线程相当于你只是买了一块cpu,还需要你自己拼装其他零件才能使用Java中Runnable和Thread的区别

热心网友 时间：2022-04-10 23:40

Java中实现线程的方式有两种，一种是继承Thread，一种是实现Runnable接口。
区别在于一个类只能继承一个父类，如果该类继承Thread,那该类就不能继承其他类了。
而java是支持一个实现多个接口的，在实现了Runnable接口的同时还能实现其他接口或继承父类，避免了点继承的局限性，同时也适合资源的共享（如：卖票）；

在实际开发中一般都是通过实现Runnable接口来实现多线程的

热心网友 时间：2022-04-11 03:28

Thread是类
Runnable是接口

我们平时如用到线程，一般继承Thread类就可以了，但如果当前类已继承了其它类，由于Java的单继承特性，这时就可以用实现Runnable接口的方式。

从另一方面讲，Runnable接口是为了因为单继承而无法继承Thread类而生的。

热心网友 时间：2022-04-11 07:33

添加线程的两种方式
第一种：通过继承Thread类来实现  使用时直接实例化继承的类
第二种：通过实现runable接口  使用时Thread thread=new Thread(new myrunable())
应为类只能继承一个类，实现多个接口，如果你继承了Tread来实现线程，将无法继承其它的类，用实现Runable接口能解决这个问题。具体怎么用看情况。

public class Threadtest {
public static void main(String[] args) {

mythread x2=new mythread();
Thread x3=new Thread(new myrunable());
x2.start();
x3.start();
System.out.println("mymain running");
}
}
class mythread extends Thread{
@Override
public void run() {
 System.out.println("mythread running");
}
}

class myrunable implements Runnable{
public void run() {
System.out.println("myrunnable running");
}
}

热心网友 时间：2022-04-11 11:54

前者是接口，要使用类去实现
后者是类，通过继承来实现
~~~~~~~~~~~~~~~~~~~~~

热心网友 时间：2022-04-11 16:32

synchronize1 t1=new synchronize1();
synchronize1 t2=new synchronize1();
Thread ta=new Thread(t1,"A");
Thread tb=new Thread(t2,"B");
这样效果就一样了，嘿嘿

热心网友 时间：2022-04-11 21:27

Runnable接口和Thread类是java中实现多线程的两中方法。
Thread类的构造方法有8个，但常用的只有4个，分别为：
Thread类中的两个最主要的方法：
（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。
（2）start()—用于启动线程。
实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过实现Runnable接口来创建并启动多线程的步骤：