Page History

It is critical to ensure that threads are activated correctly. Thread activation Thread startup can be misleading because sometimes the code appears can appear to be performing the its function correctly , whereas it may be operating in the presence of subtle concurrency issues.It is usually a mistake to invoke the run() method on a Thread object. When 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 execute, however, in are executed by the current thread instead of the Thread object itselfrather than by the newly created thread. Furthermore, if the Thread object was not constructed from a Runnable object, nor from a by instantiating a subclass of Thread that overrides fails to override the run(), then the method rather than constructed from a Runnable object, any calls to the subclass's run() method invokes would invoke Thread.run(), which itself does nothing. It is recommended that if you have Consequently, programs must not directly invoke a Thread object that extends Runnable, and you wish to execute the object's run() method in the current thread, first cast the object to a Runnable and then invoke run().

Noncompliant Code Example

The run() method of interface Runnable must be invoked in its own thread, however, this This noncompliant code example explicitly invokes it run() in the context of the current thread. :

Code Block

bgColor	#FFCCCC


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

The start() method is not invoked on the new thread newly created thread is never started because of the incorrect assumption that run() activates starts the new thread. Consequently, the statements in the run() method execute, however, in the same thread instead of the new oneare 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 which then executes the run() method.:

Code Block

bgColor	#ccccff


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

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() {

  Thread thread = new Thread(new Runnable() {
      @Override public void run() {
        // ...
      }
    });
  
  ((Runnable) thread).run();  // THI00-J-EX0: Does not start a new thread

}

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

Failing Failure to activate start threads correctly can cause unexpected behavior.

Rule	Severity	Likelihood	Remediation Cost	Priority	Level

CON05

THI00-J

low

Low

probable

Probable

medium

Medium

P4

L3

Automated Detection

TODO

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

Wiki Markup
\[[API 06\|AA. Java References#API 06]\] Interface {{Runnable}} and class {{Thread}}

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