Thread example

[Mansi Agarwal]

Hi,

Can anybody explain me the working of line4?? Want to know how super(runnable) reacts?

class Extender extends Thread {
public Extender() { }
public Extender(Runnable runnable) {super(runnable);} //line 4
public void run() {System.out.print("|Extender|");}
}
public class Implementer implements Runnable {
public void run() {System.out.print("|Implementer|");}
public static void main(String[] args) {
new Extender(new Implementer()).start(); // (1)
new Extender().start(); // (2)
new Thread(new Implementer()).start(); // (3)
}
}

[Jeanne Boyarsky]

Line 4 is calling the Thread constructor that takes a Runnable parameter. The Javadoc for this constructor shows it creates a Thread object that will delegate to the parameter's class when start/run are called.

[Mansi Agarwal]

Thanks. Got it.

But I still have one confusion. why we use super() here? As it is used to call superclass method, and is that is the case superclass, in this case "Thread" , its run() should be called which will do nothing.

Am I right?

[Jeanne Boyarsky]

The superclass' run method delegates to your Runnable's run method.

Sequence:
new Extender(new Implementer()) --> calls superclass which stores a reference to Implementer.
.start() --> calls run method on the new thread which delegates to Implementer's run method.

[Mansi Agarwal]

Thanks Jeanne.

[Don Redd]

Jeanne Boyarsky wrote:The superclass' run method delegates to your Runnable's run method.

Sequence:
new Extender(new Implementer()) --> calls superclass which stores a reference to Implementer.
.start() --> calls run method on the new thread which delegates to Implementer's run method.

I thought the code highlighted in red will call Implementers run method as you stated,,, but surprisingly!!! the above code is calling Extenders run method, not Implementers

Then, I dig into thread class and found the catch in run method implementation of Thread class

 
//Run method implementation from java.lang.Thread.
public void run() {
	if (target != null) {
	    target.run();
	}
    }

So,the conclusion is when we extend a Thread and override run method,then run method of target/Runnable is ignored

[Jeanne Boyarsky]

I stand corrected. The following outputs:
runnable
runnable
extended

Which does show that Thread only delegates to Runnable if you leave run out.

public class MyClass {

	public static void main(String[] args)  throws Exception {
		Thread t1 = new Thread(new ImplementRunnable());
		t1.start();
		Thread.sleep(1000);
		Thread t2 = new ExtendThread(new ImplementRunnable());
		t2.start();
		Thread.sleep(1000);
		Thread t3 = new ExtendThreadAndOverrideRun(new ImplementRunnable());
		t3.start();
		Thread.sleep(1000);
	}

}
class ExtendThread extends Thread {
	ExtendThread(Runnable r) { super(r); }

}

class ExtendThreadAndOverrideRun extends Thread {
	ExtendThreadAndOverrideRun(Runnable r) { super(r); }
	@Override
	public void run() {
		System.out.println("extended");
	}
}

class ImplementRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("runnable");
	}
}

[Jeanne Boyarsky]

But as a cool note, this calls the delegated Runnable via super.run() in addition to the current thread. So it makes sense - if you override run and mask the default behavior, it no longer delegates to the runnable. If you keep the superclass' run via calling it from your run, the logical behavior is still there.

        @Override
	public void run() {
		super.run();
		System.out.println("extended");
	}