关于多线程的两种实现方式的疑问

package cn.itcast.heima;
public class TraditionalThread {
public static void main(String[] args) {
new Thread(
new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("runnable :" + Thread.currentThread().getName());
}
}
}
){
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread :" + Thread.currentThread().getName());
}
}
}.start();
}
}

复制代码

在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，那么最后运行的是Thread子类覆盖的run方法中的代码。
这里，看源代码迷糊，求高手指导！

黑马_许芸 · 黑马_许芸

我将楼主的程序改写成不使用匿名内部类的格式，但是代码是完全等价的。

先贴代码：

package clone;
public class DemoTest1
{
public static void main(String[] args) {
Runnable runnable = new RunnableTest();
Thread thread = new ThreadTest(runnable);
thread.start();
}
}
class ThreadTest extends Thread
{
<font color="red">private Runnable runnable;</font> // 这行代码中的runnable在eclipse中被标为黄色警告
public ThreadTest(Runnable runnable) {
this.runnable = runnable;
}
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread :" + Thread.currentThread().getName());
}
}
}
class RunnableTest implements Runnable
{
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("runnable :" + Thread.currentThread().getName());
}
}
}

复制代码

看到我写注释的那个地方不知楼主明白了没？
Thread的run方法是这样的：
public void run() {
if (target != null) {
target.run(); // 如果传入了实现Runnable接口的类的对象，就直接调用它的run方法。
}
}
可是在你的程序中，继承自Thread的子类虽然传入了一个Runnable的参数，但是你完全没有使用它。以至于当我把它改写成不用匿名内部类的形式时，eclipse还会提示，runnable没有被使用到。

张_涛 · 张_涛

黑马_许芸发表于 2012-8-23 19:09
我将楼主的程序改写成不使用匿名内部类的格式，但是代码是完全等价的。

先贴代码：看到我写注释的那个地方 ...

是没有使用啊，可是为什么不使用呢？
Thread的run方法不是让重写了么？

黑马_许芸 · 黑马_许芸

如果你写Thread t2 = new Thread(runnable); 它执行的一定是runnable的run方法。
这是因为Thread的run方法是这样定义的。
public void run() {
if (target != null) {
target.run(); // 如果传入了实现Runnable接口的类的对象，就直接调用它的run方法。
}
}
也就是说，当这个Thread启动的时候，调用了这个Thread的run方法。然后它的run方法又调用了runnable的run方法。你懂了吗？
runnable的方法是通过Thread的run方法来调用的。
而你定义的Thread的子类的run方法中没有调用Runnable的run方法，所以，runnable的run方法根本不执行。

任文杰 · 任文杰

通过查看Thread类中的run方法的源代码：
@Override
public void run() {
      if (target != null) {
         target.run();
      }
}

其中,变量target是一个Runnable接口。若启动一个线程，首先检查是否传入实现Runnable接口的对象。如果没有传入，则直接调用子类重写的run方法。如果有传入，并且Thread的子类和实现Runnable接口的类同时覆写了run方法，这就要考虑执行顺序的问题，通过查看Thread类的源代码中的run方法，可知无论你是否传入实现Runnable接口的对象，都会首先调用Thread子类中覆写的run方法，如果此run方法没有调用传入的Runnable对象的run方法，就不会执行传入过来的的Runable对象的run方法。

杨健yj · 杨健yj

private Runnable target;
private int threadStatus = 0;
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
}
private native void start0();
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
public void run() {
if (target != null) {
target.run();
}
}

复制代码

我说一下自己的理解，希望可以帮到楼主。

首先Thread 启动一个线程 t 然后t.start()放法，先判断threadStatus != 0，因为
新的线程Status都初始化为0，表示未被使用，是一个新线程，接着加入线程池 group.add(this);
调用start0();这个方法是native的表示不是java语言实现的可能maybe是c语言实现的。
start0()描述的很清楚If this thread was constructed using a separate
   * Runnable run object, then that
   * Runnable object's <code>run</code> method is called;
   就是说如果这个Thread是使用一个Runnable对象构造就运行Runable的run方法
   否则啥也不做返回。

   后面返回了，f (stopBeforeStart) {
      stop0(throwableFromStop);
}是说如果线程还没开始就挺了就抛异常。

我也有疑惑没有调用本身的run方法啊？

邓超军 · 邓超军

我觉得应该这样理解：
即使传入了Runnable对象，或者使用其他构造函数，但是Thread子类对象已经复写了run方法并创建了对象，那么运行后Thread的run方法就会被Thread子类run方法覆盖执行。

zhaosenyang · zhaosenyang

本帖最后由 zhaosenyang 于 2015-12-23 10:26 编辑

Thread类run方法源代码：
public void run() {
      if (target != null) {
         target.run();
      }
}

target是通过构造函数传入的一个Runnable实现类，你传入了一个Runnable的匿名实现类。如果你不覆写Thread的run方法，那通过源代码可见，start调用run方法的时候调用的是Runnable实现类的run方法。但是你又覆写了Tread的run方法，
if (target != null)
{
      target.run();
}

这句代码没有了，所以start调用Tread的run方法的时候就不会调用Runnable的run方法，而是调用你覆写的run方法。

张_涛 · 张_涛

吼吼，表示真心没看懂...
早上又看了下,这么理解了。
在创建匿名内部类的时候，调用的是无参数的Thread的构造方法
关于Thread的构造方法如下：

public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}

复制代码

因此，在用匿名内部类创建Thread子类的时候，默认的调用的是无参的构造方法，最后Runnable没有传进去。
吼吼！

黑马张涛 · 黑马张涛

这个问题我的理解是：向Thread传进这个实现了run方法的Runnable对象，则运行Runnable对象的run方法，而后如果在方法体中又实现了Thead子类（匿名内部类）的run方法，则会覆盖Runnable的run方法（可以先将{}内的run方法注释掉来验证）。
因为Thread类本身就是实现了Runnable的，第一次，传进实现了run方法的Runnable对象会覆盖掉Thread类原本在实现Runnable时的run方法，第二次，当thread的子类（匿名内部类）实现run方法时，又会覆盖父类的run方法。

张_涛 · 张_涛

黑马张涛发表于 2012-8-24 11:57
这个问题我的理解是：向Thread传进这个实现了run方法的Runnable对象，则运行Runnable对象的run方法，而后如 ...

Oh,no...
不是这样的。
看了张孝祥老师的多线程知道，起码不是你说的后面的run覆盖前面的run..

寇龙飞 · 寇龙飞

哥们，简单问题想多了。

package com.itheima.test;
public class TraditionalThread {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {//----------------------------------------1------------
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("runnable :"
+ Thread.currentThread().getName());
}
}
}) {
public void run() {//----------------------------------------2---------
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread :"
+ Thread.currentThread().getName());
}
}
}.start();//----------------------------------------------------3---------
}
}

复制代码

代码中，-------3---------处star()启动的是thread匿名子类-------------2-------------处run()线程，运行结果是thread :Thread-0 .....

回头看看你帖子说的那句话：在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，那么最后运行的是Thread子类覆盖的run方法中的代码

深究一下，为什么不调用-----------1-------------处的run()方法，如果你的Thread匿名子类不覆盖run方法，那么Thread的源码是调用target的run方法，也就是Runnable类或者其子类的run方法

public void run() {
if (target != null) {
target.run();
}
}

复制代码

寇龙飞 · 寇龙飞

本帖最后由寇龙飞于 2012-8-24 14:38 编辑

Runnable也传进去了

package com.itheima.test;
public class TraditionalThread {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("runnable :"
+ Thread.currentThread().getName());
}
}
}) {
/*public void run() {
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread :"
+ Thread.currentThread().getName());
}
}*/
}.start();
}
}

复制代码

注释掉thread匿名子类的run方法，那么thread自己的run方法会调用target.run()，target是Runnable的匿名子类，运行结果：
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
runnable :Thread-0
.
.
.

帐号		自动登录	找回密码
密码			加入黑马

关于多线程的两种实现方式的疑问

12 个回复

评分

点评

评分

评分

评分

评分

黑马骑士勋章