线程问题

Question

class ThreadA extends Thread
{
   public void run()
   { 
      System.out.println("ThreadA:run()");
   }
   public void start()
   {
      System.out.println("ThreadA:start()");
   }
}
class ThreadB extends Thread
{
    public void run()
   { 
      System.out.println("ThreadB:run()");
   }
    public void start()
   {
      System.out.println("ThreadB:start()");
   }
}
public class MyTest
{
   public static void main(String args[])
   {
    ThreadB myRunnable=new ThreadB();
    Thread thread =new Thread(myRunnable);
    ThreadA myThread=new ThreadA();
    thread.start();
    myThread.start();
}}为什么输出的是
ThreadA.start()
ThreadB.run()

Answer 1

Thread
public Thread(Runnable target)分配新的 Thread 对象。这种构造方法与 Thread(null, target,gname) 具有相同的作用，其中的 gname 是一个新生成的名称。自动生成的名称的形式为 “Thread-”+n，其中的 n 为整数。 参数：
target - 其 run 方法被调用的对象。
另请参见：
Thread(ThreadGroup, Runnable, String)所以我认为thread.start()就直接调用了muRunable的run方法，而myThread.start()的myThread是直接new出来的线程，而你也重写了start()，所以就成了ThreadA.start() 
   

Answer 2

thread.start()没有被重写，调用目标线程的RUN方法，即调用ThreadB  的run()方法
myThread.start(); ThreadB的start()方法被重写

Answer 3

thread.start()没有被重写!?
不懂

Answer 4

这是Thread的源代码的一部分：
public Thread()//无参的构造
    {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, null, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }    public Thread(Runnable runnable)//用Runnable构造
    {
        daemon = false;
        stillborn = false;
        threadLocals = null;
        inheritableThreadLocals = null;
        threadStatus = 0;
        blockerLock = new Object();
        init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    }
//这两个构造函数的唯一区别是init的第二个参数，一个为runnable，一个是null。
public synchronized void start()
    {
        if(threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if(stopBeforeStart)
            stop0(throwableFromStop);
    }
    private native void start0();
    public void run()
    {
        if(target != null)
            target.run();
    }
//由于start是一个native方法，大概不能用“覆盖”这样的说法吧，不知道！
//run方法中，有一个判断，target是否为null，不为null就调用runnable的run方法
//这只能解释ThreadB.run()这个输出！
//期待高手！

Answer 5

Thread   thread   =new   Thread(myRunnable); 
thread.start()调用它本身的的run()
给你看一下run方法的源码
public void run() {
if (target != null) {
    target.run();
}
    }
target就是myRunnable，所以thread.start();这样写本身不调用重写了的 ThreadB 的run方法，不知道我LZ明白了吗

Answer 6

ThreadB   myRunnable=new   ThreadB();
Thread   thread   =new   Thread(myRunnable); 这种方法下 ThreadB 的对象是作为一个 Runnable 被传入 thread 的构造函数的，作为一个 Runnable，thread 对象只关心 myRunnable 的 run 方法，事实上，(Runnable)myRunnable 根本就没有 start 这个方法。ThreadA   myThread=new   ThreadA(); 
这种方法生成一个新的 Thread 对象。不幸的是，ThreadA 类覆写了 Thread 类的 start 方法，所以，调用 myThread.start() 时，实际上是调用了自定义的这个 start 方法。我们可怜的线程根本没有启动。因为多态的存在，用 Thread myThread = new ThreadA(); myThread.start(); 也是不行的。解决的办法是，永远不要覆写 Thread 类的 start 方法。