Parallel Algorithm Execution

Controlling the Number of Threads Used by Execution Policies in C++

How do I control the number of threads used by std::execution::par?

Abstract art representing computer programming

Controlling the number of threads used by std::execution::par in C++ can be crucial for optimizing performance and avoiding resource contention.

The C++ standard library does not provide direct control over the number of threads used by the parallel execution policy (std::execution::par). However, you can influence thread usage indirectly through various techniques.

  1. Thread Pool Libraries: Use third-party thread pool libraries that allow you to set the number of threads. For example, Intel Threading Building Blocks (TBB) or Boost.Thread.
  2. Custom Thread Pool: Implement your own thread pool to control the number of threads and use it within your parallel algorithms.

Here’s an example of using a custom thread pool with a parallel execution policy:

#include <condition_variable>
#include <execution>
#include <functional>
#include <future>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

class ThreadPool {
  ThreadPool(size_t numThreads);

  template <class F>
  void enqueue(F&& f);

  std::vector<std::thread> workers;
  std::queue<std::function<void()>> tasks;
  std::mutex queueMutex;
  std::condition_variable condition;
  bool stop;

ThreadPool::ThreadPool(size_t numThreads)
  : stop(false) {
  for (size_t i = 0; i < numThreads; ++i) {
    workers.emplace_back([this] {
      for (;;) {
        std::function<void()> task;
          std::unique_lock<std::mutex> lock(
          this->condition.wait(lock, [this] {
            return this->stop || !this->tasks.empty();
          if (this->stop && this->tasks.empty())
          task = std::move(this->tasks.front());

ThreadPool::~ThreadPool() {
    std::unique_lock<std::mutex> lock(queueMutex);
    stop = true;
  for (std::thread& worker : workers) {

template <class F>
void ThreadPool::enqueue(F&& f) {
    std::unique_lock<std::mutex> lock(queueMutex);

void Log(int number) {
  std::cout << "Number: " << number << '\n';

int main() {
  // Control the number of threads here
  ThreadPool pool(4);
  std::vector<int> numbers{1, 2, 3, 4, 5};

  for (int number : numbers) {
    pool.enqueue([number] { Log(number); });
Number: 1
Number: 5
Number: 2
Number: 4
Number: 3

In this example, a ThreadPool class is implemented to manage a fixed number of threads. The Log function is then enqueued into the thread pool, which controls the execution of tasks.

Key points:

  • C++ standard does not directly control the number of threads for std::execution::par.
  • Use thread pool libraries or custom thread pools for better control.
  • Ensure thread pools handle task synchronization and avoid race conditions.

By managing your thread pool, you can control the number of threads used in parallel execution, improving performance and resource management.

Answers to questions are automatically generated and may not have been reviewed.

A computer programmer
Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

  • 124 Lessons
  • 550+ Code Samples
  • 96% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved