黑马程序员技术交流社区

标题: Thread类和Runnable什么关系？ [打印本页]

作者: LYG 时间: 2014-4-19 21:41
标题: Thread类和Runnable什么关系？

class Ticket implements Runnable//extends Thread
{
private int tick = 100;
public void run()
{
while (true)
{
if(tick > 0)
{
System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建了一个线程;
Thread t2 = new Thread(t);//创建了一个线程;
Thread t3 = new Thread(t);//创建了一个线程;
Thread t4 = new Thread(t);//创建了一个线程;
t1.start();
t2.start();
t3.start();
t4.start();
//Ticket t1 = new Ticket();
//t1.start();
}
}

复制代码

作者: LYG 时间: 2014-4-19 21:42
补充：为什么实现了Runnable接口，下面就可以创建一个Thread类的子对象，Thread类和Runnable什么关系？

作者: 轻语。 时间: 2014-4-19 22:02
Thread是类，Runnable是接口。
如果一个类继承了其他的类还想多线程怎么办？ java不能多继承。这时候就用到Runnable接口了。
实现Runnable接口就可以了。

作者: 轻语。 时间: 2014-4-19 22:08
本帖最后由伍叶竹于 2014-4-19 22:31 编辑

查API 类Thread：
public class Thread extends Object implements RunnableRunnable定义的子类中没有start()方法，只有Thread类中才有
Thread类也是Runnable接口的子类Thread类有一个构造方法：
public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。

作者: LYG 时间: 2014-4-19 22:09

伍叶竹发表于 2014-4-19 22:02
Thread是类，Runnable是接口。
如果一个类继承了其他的类还想多线程怎么办？ java不能多继承。这时候就用 ...

为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗？

作者: 轻语。 时间: 2014-4-19 22:30

LYG 发表于 2014-4-19 22:09
为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗？ ...

class Ticket implements Runnable//extends Thread
只改这里的话是不对的。
MyRunnable implements Runable //实现Runnable接口——>
MyRunnable mr=new MyRunnable();//new实现Runnable接口的类——>
new Thread(mr).start() ; //看这里。。再看板凳。

作者: 轻语。 时间: 2014-4-19 22:33
5、创建线程的第二种方法是声明实现Runable接口的类，该类然后实现run方法。然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动，代码示例：

//实现Runable接口的类，覆写run方法
class PrimeRun implements Runable
{
long minPrimeRun;
PrimeRun(long minPrime)
{
      this.minPrime = minPrime;
}
public void run()
   {
      ...
   }
}
//创建并启动一个线程
PrimeRun p = new PrimeRun(143);
new Thread(p).start();       //等效于 Thread t = new Thread(p); t.start();
                                             //Thread类中构造方法  Thread(Runable target);  接收Runable接口类型的对象

这是看毕老师视频时做的笔记。给你参考

作者: 忘川 时间: 2014-4-19 22:59
查看java的api文档就可以知道Thread类的定义是这样的
public class Thread extends Object implements Runnable
也就是说 Thread类也是实现了Runable接口
你想要启动一个线程，就需要调用Thread.start()这个方法，再看API文档中对start方法的定义
public native synchronized void start() 使该线程开始执行; Java 虚拟机调用线程 run 方法
这句话就是说，你调用start方法，实际上就是执行Runnable接口的run方法，而Runnable接口中，仅仅定义了一个run方法
也就是说，你想创建一个Thread类的子对象，你就必须能给的出Runnable接口的run方法的具体实现，而实现这个run方法的方法，要么继承Thread类，因为Thread类继承了Runnable接口，所以子类也就间接继承了Runnable接口；要么就继承Runnable接口，然后定义Thread类的实例时将类对象作为参数传进去。
针对你的疑问：为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗
实际上，多线程从根本上来讲，就是实现Runnable接口，你继承Thread实际上也是重写Thread中Runnable接口里定义的run( )方法，只不过如果继承了Thread，你那个类就有了Thread所拥有的start方法什么的，可以直接调用，而继承了Runnable接口，你需要将你的对象作为参数传进Thread的实例中，通过调用Thread的实例的start方法来起线程，因为你自己定义的那个类里没有start方法不是
不知道我这样解释你清楚了不，不明白的话可以问我

作者: 也许依然 时间: 2014-4-20 11:30
本帖最后由也许依然于 2014-4-20 11:32 编辑

java中使用多线程有两种方法

第一种：继承Thread类
步骤：
1 定义类继承Thread
2 复写Thread类中的run方法
（Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法）
3 调用start方法

第二种：实现Runnable接口

步骤：
1 定义实现Runnable接口
2 覆盖Runnable接口中的run方法
3 通过Thread类建立线程对象
4 将Runnable类接口的子类对象作为实际参数传递给Thread类的构造函数
5 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

为什么要将Runnable接口的子类对象传递给Thread的构造函数？
因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法；就必须明确该方法所属的对象

Runnable接口中只有一个run方法，使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

实现方式和继承方式有什么区别？
实现方式好处在于：避免了单继承的局限性，在定义线程时，建议使用实现形式

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

作者: 天山 时间: 2014-4-20 12:21
package com.isoftstone.interview;

public class Ticket implements Runnable {

private int ticket = 100;

public void run() {
//线程 RUN 方法，
while (true) {
if (ticket > 1) {
System.out.println(Thread.currentThread().getName() + " "
+ ticket--);

} else {
break; // 一个判断，
}
}

}
}

package com.isoftstone.interview;

public class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();

Thread t1 = new Thread(t);// 创建了一个线程;
Thread t2 = new Thread(t);// 创建了一个线程;
Thread t3 = new Thread(t);// 创建了一个线程;
Thread t4 = new Thread(t);// 创建了一个线程;
// 4个线程一起调用 ticket类中，100ticket 参数，
t1.start();
t2.start();
t3.start();
t4.start();
}

}

作者: 微笑=.一瞬间 时间: 2014-4-20 14:47
Thread 是类一个类继承了Thread类就可以new 对象创建线程。但是java是单继承的如果你想实现线程有想实现继承假设如果你继承了Thread还如何去继承别的类呢？所以java 给我们提供了另一种创建类的方法就是一个类实现Runnable 接口然后去new 对象然后去创建线程，还可以去继承其想继承的类。不过一般情况下推荐通过一个类实现Runnable接口来创建线程，不推荐你使用Thread new对象的方法。原因我也说不清楚不过还是感觉通过类实现Runnable接口来床见线程比较好

作者: LYG 时间: 2014-4-20 19:25

忘川发表于 2014-4-19 22:59
查看java的api文档就可以知道Thread类的定义是这样的
public class Thread extends Object implements Run ...

好像都不是我要的答案，不过谢谢你们啦，毕老师的我看过才发问的，黏贴笔记的下来给我就不用啦，我自己每节都有记笔记。
谢谢你的回答啦，哥们！

作者: wyqs92 时间: 2014-4-21 21:45
Thread是类，只能单继承。而Runnable接口，Thread 类实现了 Runnable。。为什么有了继承还要提供继承了？那是因为假如有一个类，而且它是继承了某一个类，此时就不能在继承thread类了，这是单继承的局限性。。所以就要使用接口来完成。。
步骤：
1，定义一个类实现Runnable接口。
2，覆盖Runnable接口中的run方法。
将线程要运行的代码存储到run方法中。
3，创建该接口的子类对象。
4，通过Thread类进行线程的创建，并将Runnable接口的子类对象作为Thread类的构造函数的实参进行传递。
为什么要传递呢？
让线程对象创建时，就要明确要运行哪个run方法，而这个run方法是需要被对象调用的，
所以将run方法所属的对象传递给Thread类的构造函数。
5，调用Thread类中的start方法开启线程。

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

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