① java中Runnable和Thread的区别
1. 一种是通过继承Thread类，同时重写run()方法。但是java中，只允许单继承，也就是一个类只能继承一个父类，使得该方式具有一定的局限性，等下就知道了。
2. 另一种是实现Runnable类接口的run()方法，再结合Thread类来实现多线程。
两种方式最终都是通过调用start()方法来实现多线程。切记不能直接调用Thread类或Runnable对象的run()方法，因为直接调用run()方法，只会执行同一个线程中的任务，而不会启动新线程。调用start()方法将会创建一个执行run()方法的线程。
实际开发中我们通常采用Runnable接口来实现多线程。因为实现Runnable接口比继承Thread类有如下好处：
1. 避免继承的局限，一个类可以继承多个接口，但是类只能继承一个类。
2. Runnable接口实现的线程便于资源共享。而通过Thread类实现，各自线程的资源是独立的，不方便共享。
② java中runnable和thread的区别
Runnable接口和Thread类是java中实现多线程的两中方法。
Thread类的构造方法有8个，但常用的只有4个，分别为：
Thread类中的两个最主要的方法：
（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。
（2）start()—用于启动线程。
实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过实现Runnable接口来创建并启动多线程的步骤：
③ java 中Thread 和Runnable有何区别
区别：Thread是类，而Runnable是接口。
抽象类和接口的区别如下：
①
在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现接口则要实现里面的全部方法。
②在接口中无成员变量，而抽象类中可有成员变量。
在Java中引进接口主要是为了解决多继承的问题。
实现多线程主要继承Thread
类和实现Runnable接口。
④ java中runnable和thread的区别
thread 是继承了thread 类。runnable是实现了此接口，重写run方法，因为接口可以实现多个，那用后面的，将来这个类还可以继承别的类，而重写run方法，以后要实现其他业务逻辑，就不用new 线程了。
⑤ Java中Runnable和Thread的区别
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限，下面看例子
packageorg.thread.demo;
classMyThreadextendsThread{
privateStringname;
publicMyThread(Stringname){
super();
this.name=name;
}
publicvoidrun(){
for(inti=0;i<10;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
}
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
mt1.run();
mt2.run();
}
}
但是此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动
start()方法启动线程：
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
mt1.start();
mt2.start();
}
};
使用start才能正确启动现成，使用run只是方法调用。
这样程序可以正常完成交互式运行。那么为啥非要使用start()方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了privatenativevoidstart0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（javaNativeInterface）
Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
publicinterfaceRunnable{
publicvoidrun();
}
packageorg.runnable.demo;
{
privateStringname;
publicMyThread(Stringname){
this.name=name;
}
publicvoidrun(){
for(inti=0;i<100;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
}
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：publicThread(Runnabletarger)
此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）:
packageorg.runnable.demo;
importorg.runnable.demo.MyThread;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
newThread(mt1).start();
newThread(mt2).start();
}
}
两种实现方式的区别和联系
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处
避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享
以卖票程序为例，通过Thread类完成：
packageorg.demo.dff;
classMyThreadextendsThread{
privateintticket=10;
publicvoidrun(){
for(inti=0;i<20;i++){
if(this.ticket>0){
结果分析：
1. 使用Runnable对象时，Runnable定义的子类没有start()方法，只有Thread类中才有，观察Thread类，有一个构造方法public Thread(Runnable target)，此构造方法接受Runanble的子类实例，也就是说可以通过Thread类来启动Runnable实现多线程。
2. 每个线程调用的都是同一个MyRunnable对象的run()方法，访问的是同一个对象中的变量ticket实例。
Runnable和Thread区别
实际开发中我们通常采用Runnable接口来实现多线程。因为实现Runnable接口比继承Thread类有如下好处：
1. 避免继承的局限，一个类可以继承多个接口，但是类只能继承一个类。
2. Runnable接口实现的线程便于资源共享。而通过Thread类实现，
⑥ Java中Runnable和Thread的区别
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；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）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类有如下好处：避免点继承的局限，一个类可以继承多个接口。适合于资源的共享以卖票程序为例，通过Thread类完成：package org.demo.dff; class MyThread extends Thread{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println("卖票：ticket"+this.ticket--); } } } }; 下面通过三个线程对象，同时卖票：package org.demo.dff; public class ThreadTicket { public static void main(String[] args) { MyThread mt1=new MyThread(); MyThread mt2=new MyThread(); MyThread mt3=new MyThread(); mt1.start();//每个线程都各卖了10张，共卖了30张票 mt2.start();//但实际只有10张票，每个线程都卖自己的票 mt3.start();//没有达到资源共享 } } 如果用Runnable就可以实现资源共享，下面看例子：package org.demo.runnable; class MyThread implements Runnable{ private int ticket=10; public void run(){ for(int i=0;i<20;i++){ if(this.ticket>0){ System.out.println("卖票：ticket"+this.ticket--); } } } } package org.demo.runnable; public class RunnableTicket { public static void main(String[] args) { MyThread mt=new MyThread(); new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一 new Thread(mt).start();//个实例化对象mt，就会出现异常 new Thread(mt).start(); } }; 虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。Runnable接口和Thread之间的联系：public class Thread extends Object implements Runnable发现Thread类也是Runnable接口的子类。
⑦ Java中Runnable和Thread的区别
进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。
线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。
多进程是指操作系统能同时运行多个任务（程序）。
多线程是指在同一程序中有多个顺序流在执行。
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口
总结：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
⑧ java线程Thread和Runnable的区别
/*
你好,我这两天也在学这个,刚好卡住这里了,和你交流一下,也顺便提醒我一下,我尽量保持通俗,能不能看懂,全看造化了!
首先明白一点.如果你想创建一个线程,少不了Thread这个类的对象,我意思就是说,Thread是Java给我们提供的一个工具,你就暂时这么理解!
就算你用Runnable接口,你也少不了Thread这个类,只有这个类才可以帮助创建自定义的线程!
Thread相当于一个写好的工具放在那里,你可以直接拿来就用,Runnable相当于这个工具的扩展!
这个已经做好的工具,可以直接用,但是功能受到一些限制,加上这个接口功能就强大很多了!
自定义线程两种方式都离不开Thread!
第一就是:
继承他,做他的子类,子类就是一个线程类了,对象已建立就算有了线程了,然后启动即可!
第二就是:
自定义一个类去实现runnable接口,因为Thread也实现了这个接口,这就相当于,你自定义的类,和Thread都拥有相同的一个接口,你可以理解成规则!
Thread的构造函数接受runnable这种"规则"的类,这个没理由,这个是Java设计的,这点是死的!
Java用start启动就是在启动操作系统,帮你分配!
然后你可以创建一个Thread的对象,把你自定义的类对象,丢进去,然后启动,他帮你执行!
区别就是:在资源共享上面,你的自定义类,用实现接口的方式,很轻松的操控!
当然还有别的,比如说,线程休眠,唤醒,等等..我就不在例举了......
其实吧,继承thread也可以实现资源共享,这里我就不说静态变量了,其实还有别的办法!
网络上,你可以看看,千篇一律都是照着教程写的文字,我也不敢说自己总结的就很好!
多线程很重要,不要贪快!
不足之处还请指点!!!
*/
⑨ Java中Runnable和Thread的区别
1、在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；
2、Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
3、Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
4、在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享