string_view in multithreading

Yes, you can use std::string_view in multithreaded applications, but you need to be cautious about the thread safety of the underlying string.

std::string_view itself is just a non-owning, read-only view, so its safety depends entirely on the lifecycle and access patterns of the string it views.

Immutable Data

If the underlying string is immutable or only accessed in a read-only fashion across multiple threads, using std::string_view is safe. Here's an example:

1#include <iostream>
2#include <string>
3#include <string_view>
4#include <thread>
5
6void printStringView(std::string_view sv) {
7  std::cout << sv << '\n';
8}
9
10int main() {
11  std::string str{"Hello, multithreading world"};
12  std::string_view view{str};
13
14  std::thread t1(printStringView, view);
15  std::thread t2(printStringView, view);
16
17  t1.join();
18  t2.join();
19}

1Hello, multithreading world
2Hello, multithreading world

In this example, str is not modified after the std::string_view is created, making it safe to use in multiple threads.

Mutable Data

If the underlying string is modified by one thread while another thread accesses it through a std::string_view, it can lead to undefined behavior. You must synchronize access to ensure safety:

1#include <iostream>
2#include <string>
3#include <string_view>
4#include <thread>
5#include <mutex>
6
7std::mutex mtx;
8
9void printStringView(std::string_view sv) {
10  std::lock_guard<std::mutex> lock(mtx);
11  std::cout << sv << '\n';
12}
13
14int main() {
15  std::string str{"Hello, multithreading world"};
16  std::string_view view{str};
17
18  std::thread t1(printStringView, view);
19
20  // Ensure t1 completes before proceeding to t2
21  t1.join();
22
23  std::thread t2([&str, &view]() {
24    std::lock_guard<std::mutex> lock(mtx);
25    str = "New content";
26    view = str;
27    std::cout << view << '\n';
28  });
29
30  t2.join();
31}

1Hello, multithreading world
2New content

Summary

std::string_view can be used in multithreaded applications as long as you ensure the underlying string is accessed safely.

Use synchronization mechanisms like mutexes when the string can be modified by multiple threads, or ensure it remains immutable for read-only access across threads.