Page History

...

Thread startup can be misleading because the code can appear to be performing its function correctly when it is actually being executed by the wrong thread.
Invoking the Thread.start()

...

method instructs the Java runtime to start executing the thread's

...

run() method using the started thread. Invoking a Thread object's run() method directly is incorrect. When a Thread object's run() method is invoked directly, the statements in the run() method are executed by the current thread rather than by the newly created thread. Furthermore, if the Thread object was constructed by instantiating a subclass of Thread that fails to override the run() method rather than constructed from a Runnable object, any calls to the subclass's run() method would invoke Thread.run(), which does nothing. Consequently, programs must not directly invoke a Thread object's run() method.

Noncompliant Code Example

This noncompliant code example explicitly invokes run() in the context of the current thread:

Code Block

bgColor	#FFCCCC

}} method in the respective thread. It is a mistake to directly invoke the {{run()}} method on a {{Thread}} object. When invoked directly, the statements in the {{run()}} method execute in the current thread instead of the newly created thread. Furthermore, if the {{Thread}} object is not constructed from a {{Runnable}} object but rather by instantiating a subclass of {{Thread}} that does not override the {{run()}} method, then a call to the subclass's {{run()}} method invokes {{Thread.run()}} which does nothing.


h2. Noncompliant Code Example

This noncompliant code example explicitly invokes {{run()}} in the context of the current thread. 

{code:bgColor=#FFCCCC}
public final class Foo implements Runnable {
  @Override public void run() {
    // ...
  }
  
  public static void main(String[] args) {
    Foo foo = new Foo();
    new Thread(foo).run();
  }
}
{code}

The {{start()}} method is not invoked on the new thread because of the incorrect assumption that {{run()}} starts the new thread. Consequently, the statements in the {{run()}} method execute in the same thread instead of the new one.

h2. Compliant Solution

This compliant solution correctly uses the {{start()}} method to start a new thread. The {{start()}} method internally invokes the {{run()}} method in the new thread.

{code:bgColor=#ccccff}

The newly created thread is never started because of the incorrect assumption that run() starts the new thread. Consequently, the statements in the run() method are executed by the current thread rather than by the new thread.

Compliant Solution

This compliant solution correctly uses the start() method to tell the Java runtime to start a new thread:

Code Block

bgColor	#ccccff

public final class Foo implements Runnable {
  @Override public void run() {
    // ...
  }
  
  public static void main(String[] args) {
    Foo foo = new Foo();
    new Thread(foo).start();
  }
}
{code}

h2. Exceptions

*EX1*: The {{

Exceptions

THI00-J-EX0: The run()

...

method

...

may

...

be

...

directly invoked

...

during unit

...

testing

...

.

...

Note that this method cannot be used to test a class for multithreaded use.

Given a Thread object that was constructed with a runnable argument, when invoking the Thread.run() method, the Thread object may be cast to Runnable to eliminate analyzer diagnostics:

Code Block

bgColor	#ccccff

public void sampleRunTest() {

   that a class cannot be tested for multithreaded use by invoking {{run()}} directly.

{mc}{{Thread}} already implements {{Runnable}}{mc}
*EX2*: When using a {{Thread}} object that has been constructed with a distinct {{Runnable}} object, and when needing to execute the object's {{run()}} method in the current thread, the object should first be cast to a {{Runnable}} before invoking {{run()}}.

{code:bgColor=#ccccff}
Thread thread = new Thread(new Runnable() {
      @Override public void run() {
        // ...
    }
  });
// Invoking thread.run() is bad}); the
 programmer probably
 meant thread.start()
((Runnable) thread).run();  // (Admissible) WarningTHI00-J-EX0: This doesDoes not start a new thread 

{code}

Casting

...

a

...

thread

...

to

...

Runnable

...

before

...

calling

...

the run()

...

method documents that the explicit call to Thread.run()

...

is intentional.

...

Adding an explanatory comment alongside the invocation is highly recommended.

THI00-J-EX1: Runtime system code involved in starting new threads is permitted to invoke a Thread object's run() method directly; this is an obvious necessity for a working Java runtime system. Note that the likelihood that this exception applies to user-written code is vanishingly small.

Risk Assessment

Failure to start threads correctly can cause unexpected behavior.

Rule	Severity	Likelihood	Remediation Cost	Priority	Level
THI00-J	Low	Probable	Medium	P4	L3

Automated Detection

Automated detection of direct invocations of Thread.run() methods is straightforward. Sound automated determination of which specific invocations are permitted may be infeasible. Heuristic approaches may be useful.

Tool

Version

Checker

Description

CodeSonar

Include Page