Thread object constructed by runnable overrides the run method

Question

Given this sample code:

Runnable r = new Runnable() {
  public void run() {
    System.out.print("Cat");
  }
};
Thread t = new Thread(r) {
  public void run() {
    System.out.print("Dog");
  }
};
t.start();

why is the output Dog and not Cat??

Answer 1

The implementation of run in Thread simply calls the Runnable provided in the constructor, if there is one. You're overriding that code, so if the new thread simply has its run method called regardless, the Runnable is ignored. Of course, you should be able to look at the source code to check that... (I've just done so, and while I'm not going to post the source here, it does exactly what I've described.)

What you've really exposed is an encapsulation problem - Thread shouldn't have these different, potentially conflicting, ways of saying what the thread should do. Basically, you should almost never extend Thread directly. Just because it's been designed badly doesn't mean you have to abuse that poor design ;)

EDIT: This is actually documented, in a somewhat roundabout way. start() is documented as:

Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.

And run() is documented as:

If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.

So the run() method is called as per start(), but you've overridden run(), which is the only method which will call the Runnable provided in the constructor.

Note that if you'd overridden the method like this:

Thread t = new Thread(r) {
  public void run() {
    super.run();
    System.out.print("Dog");
  }
};

Then the output would be "CatDog".

Answer 2

You have overridden Thread.run so that it doesn't execute the runnable. Instead it just prints "Dog".

Answer 3

It is because the function run() is overridden. And t call this function:

public void run() {
System.out.print("Dog");
}

You will get the o/p as cat when you execute r.start() Which will call the function

 public void run() {
    System.out.print("Cat");
  }

Answer 4

Taking a look at the source code for java.lang.Thread:

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

target is the Runnable field in the Thread that the Thread(Runnable) constructor uses to assign your r variable. When you override the run method in the Thread, you're changing the behavior of run to call

System.out.print("Dog");

instead of calling

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

Answer 5

This is an anonymous class and you are redefining/overriding run. Are you using the passed-in Runnable inside your run? No you don't. So the question is, why did you expect it to print Cat?

 new Thread(r) {
  public void run() {
    System.out.print("Dog");
  }
};