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.
Thread.start() method instructs the Java runtime to start executing the thread's
run() method using the started thread. Invoking a
run() method directly is incorrect. When a
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
Noncompliant Code Example
This noncompliant code example explicitly invokes
run() in the context of the current thread:
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.
This compliant solution correctly uses the
start() method to tell the Java runtime to start a new thread:
run() method may be directly invoked during unit testing. Note that this method cannot be used to test a class for multithreaded use.
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:
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
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.
Failure to start threads correctly can cause unexpected behavior.
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.
|JAVA.CONCURRENCY.LOCK.SCTB||Synchronous Call to Thread Body (Java)|
|CERT.THI00.IRUN||Do not call the 'run()' method directly on classes extending 'java.lang.Thread' or implementing 'java.lang.Runnable'|
|S1217||Thread.run() should not be called directly|
Android Implementation Details
Android provides a couple of solutions for threading. The Android Developers Blog's article "Painless Threading" discusses those solutions.