write one ros2 c++ multithread demo, or is there a...

Below is a ready-to-compile mini C++ demo that exercises ROS 2’s MultiThreadedExecutor, followed by several official demos you can run out-of-the-box.

---

TL;DR

ROS 2 ships an official multithreaded executor sample in the ros2/examples repo and multithreaded talker/listener executables in the demo_nodes_cpp package. All use rclcpp::executors::MultiThreadedExecutor, which spins multiple callbacks in parallel to keep high-frequency timers, subscriptions, and services responsive. The self-contained code below shows the same pattern in a single node; compile it with any recent ROS 2 distro (Humble → Iron).GitHub ROS Documentation ROS Documentation ROS Documentation

---

1 A Minimal Multithreaded Demo

1.1 Code (src/dual_timer_node.cpp)

cpp
#include <chrono>
#include <memory>
#include <rclcpp/rclcpp.hpp>

using namespace std::chrono_literals;

class DualTimerNode : public rclcpp::Node
{
public:
  DualTimerNode()
  : Node("dual_timer_node")
  {
    // Timer 1: publishes fast
    timer_fast_ = this->create_wall_timer(
      50ms,                          // 20 Hz
      [this]() {
        RCLCPP_INFO(this->get_logger(), "Fast timer thread-id: %zu",
                    std::hash<std::thread::id>{}(std::this_thread::get_id()));
      });

    // Timer 2: publishes slowly and sleeps to simulate heavy work
    timer_slow_ = this->create_wall_timer(
      500ms,                         // 2 Hz
      [this]() {
        RCLCPP_INFO(this->get_logger(), "Slow timer START thread-id: %zu",
                    std::hash<std::thread::id>{}(std::this_thread::get_id()));
        std::this_thread::sleep_for(300ms);  // heavy callback
        RCLCPP_INFO(this->get_logger(), "Slow timer END");
      });
  }

private:
  rclcpp::TimerBase::SharedPtr timer_fast_;
  rclcpp::TimerBase::SharedPtr timer_slow_;
};

int main(int argc, char ** argv)
{
  rclcpp::init(argc, argv);

  auto node = std::make_shared<DualTimerNode>();

  // Spin the node with 4 worker threads
  rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 4);
  exec.add_node(node);
  exec.spin();

  rclcpp::shutdown();
  return 0;
}

1.2 Package skeleton & build

bash
# Create an ament_cmake package that depends on rclcpp
ros2 pkg create --build-type ament_cmake mt_demo --dependencies rclcpp
cd mt_demo
# Add the source file and edit CMakeLists.txt:
echo 'add_executable(dual_timer_node src/dual_timer_node.cpp)
ament_target_dependencies(dual_timer_node rclcpp)
install(TARGETS dual_timer_node DESTINATION lib/${PROJECT_NAME})' >> CMakeLists.txt
# Build
colcon build --packages-select mt_demo
source install/setup.bash

1.3 Run & observe

bash
ros2 run mt_demo dual_timer_node

You should see the fast timer continue printing even while the slow timer is sleeping, and the logs will show different thread IDs—confirmation that callbacks are executing in parallel.

---

2 Official Multithreaded Demos You Can Try Immediately

Package	Executable	What it shows	How to run
examples/rclcpp/executors/multithreaded_executorGitHub	multithreaded_executor	One publisher and one timer placed in two mutually exclusive callback groups, spun by MultiThreadedExecutor. Demonstrates how parallelism avoids starvation.	ros2 run examples_rclcpp_multithreaded_executor multithreaded_executor
demo_nodes_cpp (since Foxy)ROS Documentation	talker_multithreaded / listener_multithreaded	Canonical talker/listener pair that uses a multithreaded executor so publishing and subscription callbacks do not block one another.	ros2 run demo_nodes_cpp talker_multithreaded in one shell, ros2 run demo_nodes_cpp listener_multithreaded in another
mtexec_example (community repo)GitHub	nav_node, base_node	Shows a service and a subscription executing concurrently in separate threads using custom callback groups.	Clone repo, colcon build, then run nodes per README
Concepts tutorial “About Executors” sectionROS Documentation	N/A	Explains design trade-offs between single-threaded, multi-threaded and static executors, with code snippets in C++.	Read docs
The Construct multithreaded tutorialThe Construct	Online notebook	Step-by-step exercise that times message processing with and without multithreading.	Follow tutorial in browser

Tip: All official examples live in your ROS 2 installation under ros_ws/install/**/lib for binaries or src/ros2/examples if you cloned the source tree. Use ros2 pkg executables <pkgname> to list what is installed.

---

3 Key Points & Troubleshooting

1. Number of threads. Passing 0 to the MultiThreadedExecutor constructor lets it choose std::thread::hardware_concurrency() threads automatically.ROS Documentation
2. Callback groups. If two callbacks are placed in the same mutually exclusive group, they still serialize even in a multi-threaded executor; use reentrant groups (default) for actual parallelism. This behavior is frequently discussed on ROS Discourse and Stack Exchange.Robotics Stack Exchange
3. Starvation. Don’t create fewer threads than long-running callbacks; otherwise other callbacks may never run.Robotics Stack Exchange
4. Distro differences. Demo names haven’t changed since Humble, but older distros (e.g., Dashing) placed them under demo_nodes_cpp_native. Double-check with ros2 pkg list | grep demo.docs.ros2.org
5. Build flags. In demo_nodes_cpp you can choose a different executor at build time via the DEMO_EXECUTOR CMake flag (e.g. EventsExecutor).ROS Documentation
6. GUI inspection. Use rqt_graph to confirm that topics are flowing as expected while threads run in parallel.

---

Where to look next

• Full API: rclcpp::executors::MultiThreadedExecutor docs (Humble).ROS Documentation
• Advanced patterns: composition with intra-process communication and multi-threaded executors inside a single process.
• Performance tuning: compare callback duration with tracing (ros2 trace).

Enjoy exploring ROS 2 multithreading!

Below is a practical “cheat-sheet” that explains how many threads a ROS 2 process really owns, why you often see more threads than CPU cores, and several ways to measure or limit them.

---

Key take-aways (one-paragraph summary)

rclcpp::executors::MultiThreadedExecutor creates a pool whose size defaults to std::thread::hardware_concurrency() with a minimum of two threads when you pass 0 or omit the argument ROS Documentation ROS Documentation.
Your ROS 2 process, however, also inherits extra middleware threads (Fast DDS, Cyclone DDS, Connext, etc.), logging threads, transport threads, flow-controller threads, and sometimes OS helper threads, so the total thread count you observe in a tool like htop -H can be two-to-three times the number of virtual CPUs fast-rtps.docs.eprosima.com Fast DDS Documentation cyclonedds.io fast-rtps.docs.eprosima.com.
You can check the live count with simple Linux commands, print it from inside your node, or explicitly cap it when constructing the executor.

---

1 How many threads does the executor itself start?

Constructor call	Thread-pool size
MultiThreadedExecutor() or MultiThreadedExecutor(options, 0)	hardware_concurrency() (min 2)
MultiThreadedExecutor(options, N)	Exactly N

The behaviour is documented in the C++ API for every ROS 2 distro—from Dashing to Rolling ROS Documentation ROS Documentation and originated from the design discussion in rclcpp issue #441 GitHub.

---

2 Why you may see “too many” threads

Even if you set the pool to two, your process still hosts:

• DDS core threads (event processing, discovery, receive, send) fast-rtps.docs.eprosima.com Fast DDS Documentation
• Logging / diagnostic thread created by Fast DDS Fast DDS Documentation
• Flow-controller or asynchronous writer threads when large-data QoS is used fast-rtps.docs.eprosima.com
• Cyclone DDS helper threads, each of which can be tuned in cyclonedds.xml under <Threads> cyclonedds.io
• std::async / std::thread workers you may launch yourself, or that some third-party libraries inside the node launch.

Hence it is perfectly normal to see, say, 20–25 LWPs for a four-core VM running the stock “multithreaded executor” demo.

---

3 Checking the thread count at runtime (outside the code)

Tool / command	What it shows
htop -H -p <PID>	live list of LWPs with CPU usage
ps -L -p <PID> or ps -o nlwp <PID>	raw count via the NLWP column Ask Ubuntu
grep Threads /proc/<PID>/status	single number, good for scripts

For a one-liner:

bash
PID=$(pgrep multithreaded_executor)
echo "Threads: $(grep Threads /proc/$PID/status)"

Stack Overflow and Ubuntu man-pages confirm the nlwp trick Stack Overflow Baeldung.

---

4 Printing or logging the pool size from inside C++

cpp
#include <thread>
RCLCPP_INFO(get_logger(),
            "pool has %zu worker threads (hardware reports %u)",
            executor.get_number_of_threads(),   // C++23 rclcpp exposes this
            std::thread::hardware_concurrency());

If you are on Humble or older, there is no accessor; keep a copy of the size you passed to the constructor or read hardware_concurrency() directly.
The official multithreaded-executor demo prints this number on start-up (look for “Created multithreaded executor. Num threads: …” in its source) GitHub.

---

5 Setting a hard cap

cpp
// Limit the executor to two worker threads
rclcpp::executors::MultiThreadedExecutor exec(rclcpp::ExecutorOptions(), 2);

Passing 2 here keeps timer/subscription callbacks concurrent yet ensures the executor itself never spawns more than two workers, regardless of CPU count or hyper-threading ROS Documentation.

CLI helper for the demo binaries

The example multithreaded_executor accepts a --num-threads command-line flag (added in 2023) so you can test different pool sizes without recompiling:

bash
ros2 run examples_rclcpp_multithreaded_executor multithreaded_executor --ros-args -p num_threads:=2

(If your installation predates that patch, edit the constructor call and rebuild.)

---

6 Taming the “hidden” DDS threads (advanced)

• Fast DDS lets you disable transports you do not need (e.g., shared-memory) and tune each thread’s policy in an XML profile, shrinking the total thread count fast-rtps.docs.eprosima.com.
• Cyclone DDS exposes <Thread name="..."> entries where you can set enabled="false" or lower priorities cyclonedds.io.
• rmw_fastrtps and rmw_cyclonedds respect those XML files automatically when FASTRTPS_DEFAULT_PROFILES_FILE or CYCLONEDDS_URI is set.

Be aware that disabling discovery or transport threads can break communication; test carefully.

---

7 Troubleshooting & best practices

1. Starvation: If long-running callbacks equal or exceed your pool size, other callbacks may never run Robotics Stack Exchange.
2. VM vs. host: Inside a VM, hardware_concurrency() returns virtual CPUs; check lscpu to see what the hypervisor has exposed.
3. Hyper-threading: Expect twice as many logical CPUs as physical cores; the executor counts logical CPUs.
4. Real-time tuning: For deterministic systems, pin the executor threads (pthread_setaffinity_np) and keep DDS background threads on other cores GitHub.

---

Quick checklist

Do you…	Then…
Only want to measure	Use ps -o nlwp <PID> or htop -H.
Need to limit executor threads	Pass the desired count in the constructor.
Need to limit middleware threads	Provide an XML profile to your RMW layer.
Debug excessive threads	Count again after starting with FASTRTPS_DEFAULT_PROFILES_FILE that disables SHM and logging threads.

With these techniques you can reconcile the thread counts you see in your VM with what ROS 2 actually needs, and keep resource usage predictable.

Images:

Certainly! Here's a simple C++ program that prints the number of concurrent threads supported by your system using std::thread::hardware_concurrency():

---

🧪 C++ Demo: Print Hardware Concurrency

cpp
#include <iostream>
#include <thread>

int main() {
    unsigned int n = std::thread::hardware_concurrency();
    if (n == 0) {
        std::cout << "Unable to determine the number of concurrent threads supported.\n";
    } else {
        std::cout << n << " concurrent threads are supported.\n";
    }
    return 0;
}

---

🛠️ Build & Run Instructions

🔧 Compile the Program

If you're using GCC or Clang, compile the program with the following command:

bash
g++ -std=c++11 -pthread -o hw_threads hw_threads.cpp

Explanation of flags:

• -std=c++11: Enables C++11 features, which include std::thread.
• -pthread: Links the POSIX thread library, necessary for multithreading support.

🚀 Run the Executable

After successful compilation, run the program:

bash
./hw_threads

You should see output similar to:

8 concurrent threads are supported.

(Note: The actual number may vary depending on your system's hardware.)

---

ℹ️ Additional Information

• The function std::thread::hardware_concurrency() returns the number of concurrent threads supported by the implementation. This value is only a hint and may not be accurate. If the value is not well defined or not computable, the function returns 0.

• The number returned typically corresponds to the number of hardware threads (logical cores) available to the program. This includes considerations like hyper-threading and may be affected by system configurations or restrictions.

---

If you have any further questions or need assistance with multithreading in C++, feel free to ask!

Images:

To build and run the ROS 2 C++ demo from the multithreaded_executor example, follow these steps:

---

🧰 Step 1: Set Up Your ROS 2 Workspace

Assuming you have ROS 2 (e.g., Rolling, Humble, or Iron) installed:

bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

---

📥 Step 2: Clone the examples Repository

bash
git clone https://github.com/ros2/examples.git

This will clone the examples repository into your workspace's src directory.

---

🛠️ Step 3: Build the Workspace

Navigate to the root of your workspace and build using colcon:

bash
cd ~/ros2_ws
source /opt/ros/<ros_distro>/setup.bash  # Replace <ros_distro> with your ROS 2 distribution name
colcon build --packages-select examples_rclcpp_multithreaded_executor

Replace <ros_distro> with your installed ROS 2 distribution (e.g., rolling, humble, or iron).

---

🚀 Step 4: Source the Workspace and Run the Demo

After building, source the workspace and run the demo:

bash
source install/setup.bash
ros2 run examples_rclcpp_multithreaded_executor multithreaded_executor

You should see output indicating that the multithreaded executor is running, along with messages from the publisher and subscriber nodes.

---

🧪 Optional: Modify the Number of Threads

To specify the number of threads used by the MultiThreadedExecutor, you can modify the source code. Open the multithreaded_executor.cpp file:

bash
nano ~/ros2_ws/src/examples/rclcpp/executors/multithreaded_executor/multithreaded_executor.cpp

Locate the line where the executor is created:

cpp
rclcpp::executors::MultiThreadedExecutor executor;

Modify it to specify the desired number of threads (e.g., 4):

cpp
rclcpp::executors::MultiThreadedExecutor executor(rclcpp::ExecutorOptions(), 4);

Save the file and rebuild the package:

bash
cd ~/ros2_ws
colcon build --packages-select examples_rclcpp_multithreaded_executor

Then, source the workspace and run the demo again:

bash
source install/setup.bash
ros2 run examples_rclcpp_multithreaded_executor multithreaded_executor

This will run the demo using the specified number of threads.

---

🧠 Additional Tips

• Understanding Executors: For more information on ROS 2 executors, refer to the ROS 2 documentation on executors.
• Exploring Other Examples: The examples repository contains various other examples demonstrating different ROS 2 features. Feel free to explore them to deepen your understanding.

If you encounter any issues or have further questions, feel free to ask!

Images:

Certainly! Here's a minimal C++ example demonstrating the use of ROS 2's MultiThreadedExecutor. This example sets up a node with two timers: one fast and one slow. The slow timer simulates a long-running task by sleeping for a short duration. Using the MultiThreadedExecutor, both timers can operate concurrently without blocking each other.

---

🧪 Minimal ROS 2 MultiThreadedExecutor Example

File: src/multithreaded_timer_node.cpp

cpp
#include <chrono>
#include <memory>
#include <thread>
#include <rclcpp/rclcpp.hpp>

using namespace std::chrono_literals;

class MultiThreadedTimerNode : public rclcpp::Node
{
public:
  MultiThreadedTimerNode()
  : Node("multi_threaded_timer_node")
  {
    // Fast timer: triggers every 100ms
    fast_timer_ = this->create_wall_timer(
      100ms,
      [this]() {
        RCLCPP_INFO(this->get_logger(), "Fast timer callback");
      });

    // Slow timer: triggers every 500ms and sleeps for 300ms
    slow_timer_ = this->create_wall_timer(
      500ms,
      [this]() {
        RCLCPP_INFO(this->get_logger(), "Slow timer callback start");
        std::this_thread::sleep_for(300ms);
        RCLCPP_INFO(this->get_logger(), "Slow timer callback end");
      });
  }

private:
  rclcpp::TimerBase::SharedPtr fast_timer_;
  rclcpp::TimerBase::SharedPtr slow_timer_;
};

int main(int argc, char * argv[])
{
  rclcpp::init(argc, argv);
  auto node = std::make_shared<MultiThreadedTimerNode>();

  // Create a MultiThreadedExecutor with 2 threads
  rclcpp::executors::MultiThreadedExecutor executor(rclcpp::ExecutorOptions(), 2);
  executor.add_node(node);
  executor.spin();

  rclcpp::shutdown();
  return 0;
}

---

🛠️ Build Instructions

1. Create a new ROS 2 package:

   bash
   ros2 pkg create --build-type ament_cmake multithreaded_executor_demo --dependencies rclcpp

2. Add the source file:

   Place the multithreaded_timer_node.cpp file into the src directory of your package.

3. Modify CMakeLists.txt:

   Add the following lines to your CMakeLists.txt to build the executable:

   cmake
   add_executable(multithreaded_timer_node src/multithreaded_timer_node.cpp)
   ament_target_dependencies(multithreaded_timer_node rclcpp)
   install(TARGETS
     multithreaded_timer_node
     DESTINATION lib/${PROJECT_NAME})

4. Build the package:

   bash
   cd ~/ros2_ws
   colcon build --packages-select multithreaded_executor_demo

5. Source the workspace and run the node:

   bash
   source install/setup.bash
   ros2 run multithreaded_executor_demo multithreaded_timer_node

---

✅ Expected Behavior

With the MultiThreadedExecutor, both timers operate concurrently:

• The fast timer prints a message every 100ms.
• The slow timer prints a start message, sleeps for 300ms, then prints an end message every 500ms.

Because of the multithreaded execution, the fast timer continues to operate without being blocked by the slow timer's sleep duration.

---

📚 Additional Resources

For more detailed examples and explanations, you can refer to the official ROS 2 examples repository:

• ROS 2 Examples: multithreaded_executor.cpp

This example demonstrates the use of callback groups and multiple nodes with the MultiThreadedExecutor.

Feel free to explore and modify these examples to better understand multithreaded execution in ROS 2!

---

When you launch even the simplest ROS 2 C++ program, the executor thread you create is only a small part of the story.
Most of the 8-10 extra lightweight-processes (threads) you see in htop or ps -L are started by the underlying DDS middleware (Fast DDS by default, Cyclone DDS, Connext, etc.), plus a few helper threads from rclcpp and the C++ standard library. In other words, the SingleThreadedExecutor really is single-threaded—​it just shares its process with many other components that need their own threads to keep the network, timers and logging working.

---

1 Executor thread ≠ Process threads

• SingleThreadedExecutor runs callbacks in the same thread that calls spin(); it creates no worker pool of its own. The multi-threaded version only enlarges that pool. ROS Documentation
• Your empty node therefore contributes exactly one extra thread (the spin loop) to the process; all other threads come from elsewhere.

---

2 Where the extra threads come from

2.1 Fast DDS (default RMW layer)

Fast DDS starts several dedicated threads per DomainParticipant, for example Fast DDS Documentation:

Purpose (Fast DDS)	Typical count	Notes
Transport reception (UDP + SHM)	≥ 2	One per builtin transport
Timed-events / heartbeat	1	Drives reliability timers
Discovery & Type-Lookup	1–2	Finds peers, exchanges type info
Logging consumer	1	Feeds the async log queue Fast DDS Documentation

These already add 6-7 threads before your code runs.

2.2 Cyclone DDS (if you switch RMW)

Cyclone DDS creates similar helper threads—each individually tunable in <Threads> XML stanzas such as receiver_thread, event_thread, watchdog_thread, etc. cyclonedds.io

2.3 ROS 2/rclcpp helpers

• Guard-condition watcher and signal handlers inside rclcpp run in detached C++11 threads to keep the wait-set responsive. nu-msr.github.io
• Standard-library calls (e.g., std::async) inside third-party dependencies may also spawn background workers.

2.4 Why you saw “9”

On a typical desktop Fast DDS configuration:

text
1  executor/spin loop
1  DDS timed-events
2  UDP receive workers
2  shared-memory receive workers
1  participant discovery
1  Type-Lookup
1  Fast DDS async logger
-------------------------
9  total threads

Community reports match this order of magnitude, even for nodes that “do nothing” ROS Discourse Robotics Stack Exchange.

---

3 Inspecting and counting threads

bash
PID=$(pgrep dummpy_node)      # your process name here
ps -o nlwp,cmd -p $PID        # NLWP column = #threads
htop -H -p $PID               # live per-thread view
grep Threads /proc/$PID/status

These methods are the standard Linux way to verify what ROS 2 launches under the hood. The Construct

---

4 Can I reduce the number?

Yes—mostly by configuring the DDS layer, because that is where the surplus threads originate.

4.1 Fast DDS

• Provide an XML profile that disables transports you do not need (e.g., shared-memory on a tiny VM) or switches to SYNCHRONOUS_PUBLISH_MODE, which removes the background writer thread. Fast DDS Documentation Fast DDS Documentation
• Every built-in thread has a <ThreadSettings> block (priority, stack, enabled flag) in the XML schema Fast DDS Documentation.

4.2 Cyclone DDS

• Use CYCLONEDDS_URI=<file>.xml and set enabled="false" for unneeded threads inside <Threads>. cyclonedds.io cyclonedds.io

4.3 Executor

Limiting the executor pool (e.g., MultiThreadedExecutor(..., 2)) helps only when you switch to the multi-threaded executor; it does not affect the middleware threads.

4.4 Trade-offs

Removing DDS threads may save memory or avoid oversubscription on small VMs, but it usually comes at the cost of lower throughput or slower discovery. Measure before and after, especially on embedded targets ROS Discourse.

---

5 Key take-aways

1. One executor thread, many middleware threads—seeing ~9 threads for a “do-nothing” node is normal.
2. Most threads belong to DDS for reception, discovery, timers and logging.
3. Control them via Fast DDS or Cyclone DDS XML, not via the rclcpp executor.
4. Use ps, htop -H, or /proc/<pid>/status to confirm changes.
5. Always test performance; disabling threads can hurt latency under load.

With this picture in mind, the extra threads you observe are expected and configurable, not a malfunction of SingleThreadedExecutor.