CODEWITHSUNDEEP
javamultithreadingrunnable
S.Ptr
S.Ptr

Reputation: 122

Thread field inside a class that implements Runnable, which instantiates said class

In my school's program solutions for multithreading problems and exercises, classes that implement the Runnable interface are usually given a Thread field, which is automatically instantiated in the following example:

protected Thread thr = new Thread(this);

This field is subsequently used as a means of controlling the Thread over which the class itself is instantiated. For example:

public void stop() {
    if (thr != null) thr.interrupt();
}

Which is then used to interrupt Thread objects made with the Runnable class.

A full class example, ported directly from an aforementioned solution, is given below:

package hokej;
import java.awt.Color;
public abstract class AktFigura extends Figura implements Runnable {
    protected Thread nit = new Thread(this);
    private int tAzur;
    private boolean radi;
    public AktFigura(Scena s, int xx, int yy,
    Color b, int t) {
        super(s, xx, yy, b); tAzur = t;
    }
    protected abstract void azurirajPolozaj();
   public void run() {
   try {
       while (!Thread.interrupted()) {
           synchronized (this) {
                if (!radi) wait();
           }
           azurirajPolozaj();
           scena.repaint();
           Thread.sleep(tAzur);
       }
   } catch (InterruptedException ie) {}
   }
   public synchronized void kreni() {
       radi = true; notify();
   }
   public void stani() { radi = false; }
   public void prekini() {
       if (nit != null) nit.interrupt();
   }
}

My question is this: How does this work?
Shouldn't the Thread field be a separate object from the object made by calling new Thread(class); in other parts of the program (hence the keyword's name - new)?
Or is this simply a special case that the Java interpreter recognizes in a certain way?

Another question would be the viability of this design as a control method. Is there any simpler/more efficient alternative for controlling a Runnable's thread?

Upvotes: 1

Views: 229

Answers (1)

Andrew
Andrew

Reputation: 49606

How does this work?

The Thread constructor takes a Runnable, Thread implements this interface. this refers to a Thread instance. So, the statement Thread thr = new Thread(this) is valid, but this practice should be avoided.

Is there any simpler/more efficient alternative for controlling a Runnable's thread?

Thread thread = new Thread(new AktFiguraImpl());
thread.start();

You could control a thread by a class specifically designed for that purpose.

class ThreadController {
    public ThreadController(Thread thread, AktFigura figura) { ... }

    // methods to manipulate the thread
}

Upvotes: 3

Related Questions