需要对Java线程进行一些澄清：start（）和run（）

Question

According to the StackOverflow answers, start() creates a thread and executes the code in this new thread and run() executes the code in the current thread without creating any - as if it was a Runnable

But the docs, if I understood them properly, say that start() initializes a new thread an then, if you want to re-execute your code in the same thread, you call run()

Which one is right?

UPD

Okay, looks like calling run() manually is not a good practice and is at least useless. Are there some good ways to call the code in run() ? Say, I have a relatively slow action that is required frequently, one instance at a time - what then?

Answer 1

As quoted, neither of them is right.

start doesn't create or initialize a thread. It starts a thread. From the documentation :

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

The thread is created and initialized by calling the Thread constructor, which naturally you have to do prior to calling start . (That's the "external myth," anyway; I'd have to check the JVM spec, but I suspect it would probably be valid for a JVM to defer actual creation of the OS thread until/unless you called start .)

In the normal case, you never call the run method of a Thread instance directly. Instead, you start the thread via start and the JVM schedules a call to run on the actual thread assigned to that Thread instance. If you call run directly, it gets called on the thread you're using to do that, which probably isn't the one assigned to the Thread instance.

You may find the Java concurrency tutorial useful.

---

Re your comment below:

And how to re-execute the code in run() ? Restart the thread or have some infinite loop with a boolean value controlling the execution?

The latter, but not an infinite loop, a loop with a termination condition. From the start documentation:

It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.

So once run returns, that's it, you can't keep using the thread. Instead, you have the thread not return from run until its work is done. If you want to keep it around waiting for work, it should wait on a semaphore of some kind that you can signal from outside the thread, to wake it up to do some work.

A subsection of the tutorial above talks about one way to do that with Guarded Blocks using wait and notify / notifyAll .

---

Here's a simple example where every call to System.out.println prints the name of the thread on which the call was made so you can see which thread does what:

Live Copy

class Example
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Thread t= new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ": Running run");
            }
        });
        System.out.println(Thread.currentThread().getName() + ": Running main");
        System.out.println(Thread.currentThread().getName() + ": Calling t.start()");
        t.start();
        System.out.println(Thread.currentThread().getName() + ": Calling t.join() to wait for thread exit");
        try {
            t.join();
        } catch (InterruptedException ie) {
            System.out.println(Thread.currentThread().getName() + ": Calling got InterruptedException");
        }
        System.out.println(Thread.currentThread().getName() + ": Program complete");
    }
}

Example output:

main: Running main
main: Calling t.start()
main: Calling t.join() to wait for thread exit
Thread-0: Running run
main: Program complete

Note that our main thread just called start ; then the JVM set things up so that run would be called on the thread we'd created.

Answer 2

Your confusion probably comes from the ambigous use of the terms thread , create and initialize . Without specifying what they exactly address its easy to misunderstand, because there are multiple concepts that the term thread is used to describe.

On one hand, there is the Thread object (that is created through new Thread(...) constructor). Thats not the thread in terms of actually executing anything. Its just a facade for the threading mechanism that implements a standardized API to interact with the OS/VM.

Just creating a Thread instance is basically not any different from creating any other java object. Nothing happens yet that has anything to do with actually adding a thread to the OS thread scheduler.

The thread on the OS side is actually created in a (private) native method start0(), the start() method performs some sanity checking, then calls start0() to actually create an OS-Level thread.

So the general order of actions is:

• Create and Initialize a Thread-Object
  • Nothing out of the ordinary happens yet
• You invoke start() on above Thread-Object
  • Delegates to native code to create an OS-Level thread. Entry point for the OS-Level thread is Thread.run() on the java side.
  • Executes Thread.run() on the new thread (default implementation of run delegates to the Runnable the Thread object was created with, or does nothing if no Runnable)

Answer 3

Here is the main difference between start() and run():

Thread#start : when program calls start() method the Java Virtual Machine calls the run method of this thread.

Thread#run : If you call run() method directly code inside run() will execute on current Thread.

Answer 4

if I understood them properly, say that start() initializes a new thread an then, if you want to re-execute your code in the same thread, you call run()

This is incorrect. You need to understand that every Java program begins it's execution with the main thread. In other words, when you run a Java program that has a main method (eg java MyProgram), a new execution stack is created with the main method at the bottom of this stack.

If a program creates a Thread instance in the main method and calls the start method on the thread instance, a new execution stack will be created with the run method at the bottom of the stack. You will now have two execution stacks. One with the main method at the bottom of the stack and the other with the run method at the bottom of the stack. These two stacks can complete their execution in parallel.

On the other hand, If you call run on a thread instance in the main method instead, it will simply be called in the same execution stack as the main method. A new execution stack will not be created. Therefore, calling run on a thread instance is as good as calling any other method on any other object and has no special meaning.