黑马程序员技术交流社区

标题: 多线程中继承Thread和实现Runnable的区别是什么？ [打印本页]

作者: 素人 时间: 2013-10-23 21:40
标题: 多线程中继承Thread和实现Runnable的区别是什么？
多线程中继承Thread和实现Runnable的区别是什么？

作者: 终结者 时间: 2013-10-23 22:06
1)当多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU(线程)同程序的代码、数据有效的分了，较好地体现了面向对象的设计思想。
2)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
3）可以避免由于java的单继承特性带来的局限。

作者: 马晓平 时间: 2013-10-23 22:28
通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中. 通过实现Runnable接口，实例化Thread类

作者: 漫步人 时间: 2013-10-23 22:31
本帖最后由漫步人于 2013-10-23 23:04 编辑

两种方式区别：
继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。

实现Runnable接口相对于继承Thread类来说，有如下的显著优势：
1.适合多个相同代码的线程去处理同一个资源的情况
2.可以避免由于java的单继承特性带来的局限
3.增强了程序的健壮性，代码能够被多个线程共享，代码与数据时独立的
给你个例子，你自己取运行就知道了，好好对比下
1 class MyThread extends Thread{       // 继承Thread类，作为线程的实现类
2       private int ticket = 5 ;             // 表示一共有5张票
3       public void run(){       // 覆写run()方法，作为线程的操作主体
4                for(int i=0;i<100;i++){
5                      if(this.ticket>0){
6                               System.out.println("卖票：ticket = " + ticket--) ;
7                      }
8                }
9       }
10 };
11 public class ThreadDemo0{
12       public static void main(String args[]){
13                MyThread mt1 = new MyThread() ;       // 实例化对象
14                MyThread mt2 = new MyThread() ;       // 实例化对象
15                MyThread mt3 = new MyThread() ;       // 实例化对象
16                mt1.run() ;       // 调用线程主体
17                mt2.run() ;       // 调用线程主体
18                mt3.run() ;       // 调用线程主体
19       }
20 };
21
22
23 class MyThread implements Runnable{       // 继承Thread类，作为线程的实现类
24       private int ticket = 5 ;             // 表示一共有5张票
25       public void run(){       // 覆写run()方法，作为线程的操作主体
26                for(int i=0;i<100;i++){
27                      if(this.ticket>0){
28                               System.out.println("卖票：ticket = " + ticket--) ;
29                      }
30                }
31       }
32 };
33 public class RunnableDemo0{
34       public static void main(String args[]){
35                MyThread mt = new MyThread() ;       // 实例化对象
36                new Thread(mt).run() ;       // 调用线程主体
37                new Thread(mt).run() ;       // 调用线程主体
38                new Thread(mt).run() ;       // 调用线程主体
39       }
40 };

简单的来说，就是继承和实现接口的区别。
1、当使用继承的时候，主要是为了不必重新开发，并且在不必了解实现细节的情况下拥有了父类我所需要的特征。它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，
2、java只能单继承，因此如果是采用继承Thread的方法，那么在以后进行代码重构的时候可能会遇到问题，因为你无法继承别的类了，在其他的方面，两者之间并没什么太大的区别。
3、implement Runnable是面向接口，扩展性等方面比extends Thread好。
4、使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。

作者: 随心而动 时间: 2013-10-23 22:46
#在这里快速回复#1 继承 Thread 线程代码存放在Thread子类的run方法中，实现Runable线程存放在接口子类的Run方法中。实现的好处：避免了单继承的局限性。

作者: qixing0918 时间: 2013-10-24 09:07
本帖最后由 qixing0918 于 2013-10-24 09:10 编辑

以前写过一次再写一次希望对你有帮助

1.首先两种继承的区别
无论是继承Thread类的线程还是实现接口runable的线程都是通过Thread类start（）方法调用完成的这个类就像是工人而线程就是工作
2.其次看实现方式
class A extends Thread
{
}
class B implements runnable
{
}
//测试
因为 A 是继承Thread 所以直接调用 start()就行
A a1 = new A() ; // 实例化对象
A a2= new A() ;  // 实例化对象
  A a3 = new A() ;  // 实例化对象
a1.start() ; // 调用线程主体
a2.start() ; // 调用线程主体
a3.start() ; // 调用线程主体

而 B是是实现了接口 runnable （其实 thread 类也实现了runnable 接口并保存了 runable的引用实现start（）方法都是通过调用runnable实现的就像是监听者模式的 notifyAll()方法一样）

B b = new B() ; // 实例化对象
new Thread(b).start() ; // 调用线程主体
new Thread(b).start() ; // 调用线程主体
new Thread(b).start() ; // 调用线程主体

实现方式是不很不同 A 就像一个工人一个任务 B 则是多个工人一个任务
其实都是调用你定义的线程A 或 B 的run（）方法
那问题来了怎么不直接调用而用start() 呢（start()也是调用run()）
我感觉就是跟底层有关也就是你在main线程中调用新线程是跟jvm 跟系统cpu有关的

1、Runnable适合于多个相同程序代码线程去处理统一资源的情况，把虚拟的cpu（线程）同程序的代码，数据有效分离，较好体现面向对象的编程的思想
2、Runnable可以避免由于java的单继承机制带来的局限。可以再继承其他类的同时，还能实现多线程的功能。
3、Runnable能增加程序的健壮性。代码能够被多个线程共享。

如果都完成3个任务
3个工人去完成3个任务有两种
1. 3个人每个人完成一个任务 3个人完成3个
2. 3个人一起完成一个两个三个
效率是一样的只是一个任务的完成方式不同而已

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2