Difference Between Running and Starting a Thread

Difference between running and starting a thread

Thread.run() does not spawn a new thread whereas Thread.start() does, i.e Thread.run actually runs on the same thread as that of the caller whereas Thread.start() creates a new thread on which the task is run.

What is the difference between Thread.start() and Thread.run()?

No, you can't. Calling run will execute run() method in the same thread, without starting new thread.

What's the difference between Thread start() and Runnable run()

First example: No multiple threads. Both execute in single (existing) thread. No thread creation.

R1 r1 = new R1();
R2 r2 = new R2();

r1 and r2 are just two different objects of classes that implement the Runnable interface and thus implement the run() method. When you call r1.run() you are executing it in the current thread.

Second example: Two separate threads.

Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);

t1 and t2 are objects of the class Thread. When you call t1.start(), it starts a new thread and calls the run() method of r1 internally to execute it within that new thread.

Java multithreading difference between run() and start()

It's amazing how many people can answer a question by repeating what the OP already wrote without actually answering the question.

The solution is that you are first asking for the name of the running thread, but the second time you ask for the name of the thread insurance where the code or executed. If you change the later to Thread.currentThread instead of this you will get the expected answer.

When would you call java's thread.run() instead of thread.start()?

You might want to call run() in a particular unit test that is concerned strictly with functionality and not with concurrency.

Difference between run thread on a static method vs running with class object

In your first example, you are not starting a thread at all. You are calling the run() function in your main thread, where it blocks. To start the thread, you need to call

reply.start()

not

reply.run()

What precisely is the difference between calling run() and start() on a new thread when both(!) actually spawn a new thread?

You are falling for a very common trap with the Thread API: the failure to distinguish a thread from an instance of the Thread class. These two are completely different concepts: a thread is not even an object, it is the system resource that does the execution of your code. A Thread, on the other hand, is just a plain Java object, which happens to have some magic methods, the most magical being start(). Many others are just plain old Java methods, and they pertain to that particular Thread instance.

getName() is just such a method and it returns the name of this instance on which it was called. currentThread(), on the other hand, is a static method which returns the instance of Thread responsible for the current thread. This is the instance on which you want to invoke getName().

Running Thread by calling start() and run(), what is the difference?

start() runs the code in run() in a new thread. Calling run() directly does not execute run() in a new thread, but rather the thread run() was called from.

If you call run() directly, you're not threading. Calling run() directly will block until whatever code in run() completes. start() creates a new thread, and since the code in run is running in that new thread, start() returns immediately. (Well, technically not immediately, but rather after it's done creating the new thread and kicking it off.)

Also, you should be implementing runnable, not extending thread.

---

Related Topics