Thread Creation Techniques in RocketMQ Source Code

RocketMQ is an open‑source distributed messaging system that provides low‑latency, high‑reliability publish/subscribe services. This article summarizes several techniques used in RocketMQ's source code for creating and managing threads.

1. Creating a Single Thread

Two common ways to create a single thread in Java are:

Implementing the Runnable interface.

Extending the Thread class.

Implement Runnable

The MyRunnable class implements Runnable and defines the task logic in its run method; a Runnable instance is passed to the thread constructor.

Extend Thread

A class that extends Thread also implements the run method, effectively providing the same functionality.

2. Single‑Thread Abstract Class

To avoid repetitive code, RocketMQ defines an abstract class ServiceThread that encapsulates common thread operations such as naming, starting, and shutting down.

The core methods of ServiceThread are:

Define thread name.

Start the thread.

Shutdown the thread.

Implementations only need to override getServiceName and run, then call start to launch and shutdown to stop.

3. Thread‑Pool Principle

Thread pools manage a set of reusable threads to avoid the overhead of frequent creation and destruction. RocketMQ uses ThreadPoolExecutor from the JDK.

Key constructor parameters include:

Parameter

Purpose

corePoolSize

Maximum concurrent threads when the queue is not full

maximumPoolSize

Maximum threads after the queue is full

keepAliveTime

Time after which idle threads are reclaimed

unit

Time unit for keepAliveTime workQueue

Blocking queue type for pending tasks

threadPoolFactory

Customizes thread name, group, priority, daemon status

RejectedExecutionHandler

Handles tasks that exceed pool capacity

The execution flow of execute follows four steps: create a core thread, queue the task, create a non‑core thread if the queue is full, or apply the rejection policy.

4. Thread‑Pool Encapsulation

RocketMQ wraps ThreadPoolExecutor in a custom class BrokerFixedThreadPoolExecutor, which sets core and maximum thread counts based on CPU cores, a 1‑minute idle timeout, a bounded queue of 10,000, and a custom ThreadFactoryImpl that prefixes thread names (e.g., SendMessageThread_).

The custom thread factory can also specify whether threads are daemon threads.

5. Importance of Thread Names

Descriptive thread names greatly simplify troubleshooting via log files and stack traces. RocketMQ consistently assigns meaningful names to both single‑thread abstractions and pooled threads, enabling quick identification of problematic components.

Typical diagnostics include:

Inspecting ERROR logs to trace the executing thread.

Analyzing thread‑specific logs to detect missing end markers.

Using jstack -l <pid> to capture stack snapshots and examine thread counts, blocked locks, and CPU usage.

jstack -l <process_id>

6. Summary

The article introduces RocketMQ's thread creation strategies:

Use the ServiceThread abstract class to avoid boilerplate code.

Encapsulate thread pools with custom factories and tuned parameters.

Assign clear thread names to improve debugging via logs and stack traces.

Future articles will explore additional multithreading techniques such as thread communication, concurrency control, and the overall thread model in RocketMQ.