如果一个方法属于另一个扩展Thread的类但从主线程调用，则该方法是由主线程还是子线程执行？ （JAVA）

Question

I know there are some similar questions out there, but I couldn't find one specifically answering this question - apologies if I was wrong, and there is. Would the test.toString() method be executed by the main thread, or the test thread that I started prior to it being called? A group of us are arguing about this for test revision and I am curious to what the answer is.

public class Main {
   public static void main(String[] args) {
       test = new ThreadTest("Test", 3);
       test.start();
       System.out.println(test.toString());
   }
}
public class ThreadTest extends Thread {
   public ThreadTest(String n, int x) {
       setName(n);
   }
   @Override
   public String toString() {
       return(getName() + ": x = " + x);
   }
   public void run() {
       //Nothing of any relevance to the problem occurs here
   }
}

Answer 1

Calls are always executed on the calling thread. Masses of code are based on this - for example the whole security and transaction infrastructure of the spring framework.

This fact can be proved rather easy:

public class Main {
    static ThreadLocal<String> threadContext = new ThreadLocal<String>();

    public static void main(String[] args) throws InterruptedException {
        threadContext.set("Main");
        TestThread test = new TestThread();
        new Thread(test).start();
        System.out.println("Main: " + test.getContext());
    }

    static class TestThread implements Runnable {
        @Override
        public void run() {
            threadContext.set("ThreadTest");
            System.out.println("TestThread: " + getContext());
        }

        String getContext() {
            return threadContext.get();
        }
    }
}

And as @DavidEhrmann already said: You should implement Runnable instead of extending Thread .

Answer 2

The toString() call is executed on the main thread. The main thread is invoking Main.main() ; main() directly invokes test.toString() .

Just because your output prints the string "Test" doesn't mean that's the thread that is executing it. Thread has state; setName(...) sets that state (and your class TestThread is a subclass of Test so it inherits this as well). In your toString() implementation you're just printing that state... not the actual name of the executing thread.

To prove this, change your TestThread.toString() method to also print the name of the currently executing thread and re-run:

   @Override
   public String toString() {
       return(getName() + ": x = " + x + " executed on thread " + Thread.currentThread().getName());
   }

You will see the following print to standard out:

Test: x = 3 executed on thread main

Full code:

public class Main {
       public static void main(String[] args) {
           ThreadTest test = new ThreadTest("Test", 3);
           test.start();
           System.out.println(test.toString());
       }    


}

public class ThreadTest extends Thread {
    private int x;
       public ThreadTest(String n, int x) {
           setName(n);
           this.x = x;

       }
       @Override
       public String toString() {
           return(getName() + ": x = " + x + " executed on thread " + Thread.currentThread().getName());
       }
       public void run() {
           //Nothing of any relevance to the problem occurs here
       }
}