Using std::ranges::subrange with Multi-threaded Code

When using std::ranges::subrange in multi-threaded code, it's important to understand how subranges interact with shared data.

Subranges themselves are lightweight and non-owning, meaning they do not manage the lifetime of the underlying data. This can lead to potential issues if the underlying container is modified concurrently.

Read-Only Access

If your std::ranges::subrange is only being used for read-only access, you can safely use it across multiple threads.

Each thread can iterate over the subrange without modifying the underlying data. For example:

1#include <iostream>
2#include <ranges>
3#include <thread>
4#include <vector>
5
6void print_subrange(std::ranges::subrange<
7  std::vector<int>::iterator> view) {
8  for (int n : view) {
9    std::cout << n << ", ";
10  }
11}
12
13int main() {
14  std::vector<int> Nums{1, 2, 3, 4, 5};
15  std::ranges::subrange view{Nums};
16
17  std::thread t1(print_subrange, view);
18  std::thread t2(print_subrange, view);
19
20  t1.join();
21  t2.join();
22}

11, 2, 3, 4, 5, 1, 2, 3, 4, 5,

Concurrent Modification

If you need to modify the underlying container while using a subrange, you must ensure proper synchronization to avoid data races.

This typically involves using mutexes or other synchronization primitives. For example:

1#include <iostream>
2#include <mutex>
3#include <ranges>
4#include <thread>
5#include <vector>
6
7std::mutex mtx;
8
9void modify_subrange(std::ranges::subrange<
10  std::vector<int>::iterator> view) {
11  std::lock_guard<std::mutex> lock(mtx);
12  for (int& n : view) {
13    n += 1;  
14  }
15}
16
17int main() {
18  std::vector<int> Nums{1, 2, 3, 4, 5};
19  std::ranges::subrange view{Nums};
20
21  std::thread t1(modify_subrange, view);
22  std::thread t2(modify_subrange, view);
23
24  t1.join();
25  t2.join();
26
27  for (int n : Nums) {
28    std::cout << n << ", ";
29  }
30}

13, 4, 5, 6, 7,

Guidelines

• Read-Only Access: Safe to use across multiple threads without additional synchronization.
• Modifications: Ensure proper synchronization when modifying the underlying container.
• Lifetime Management: Ensure the underlying container outlives the subranges.

Summary

Using std::ranges::subrange in multi-threaded code can be efficient and powerful when done correctly. Always consider the synchronization requirements and the lifetime of the underlying data to avoid race conditions and undefined behavior.