{"id":191,"date":"2023-04-06T09:09:47","date_gmt":"2023-04-06T09:09:47","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=191"},"modified":"2023-08-23T16:22:30","modified_gmt":"2023-08-23T16:22:30","slug":"modern-cpp-multithreading-techniques","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/","title":{"rendered":"Modern C++ Multithreading Techniques: Unlocking the Power of Concurrent Programming"},"content":{"rendered":"\n

Concurrency and multithreading have become increasingly important in the world of software development as the need to leverage multiple cores and processors for improved performance and efficiency grows. With the advent of modern C++, developers now have access to a robust set of multithreading tools and techniques that can help them create more efficient and powerful applications. This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17 standards. Our target audience is experienced developers who are looking to expand their knowledge of concurrent programming in C++.<\/p>\n\n\n\n

1. Overview of C++ Multithreading Concepts<\/h2>\n\n\n\n

1.1 Threads<\/h3>\n\n\n\n

A thread is the smallest unit of execution within a process. Multithreading allows multiple threads to run concurrently within a single process, sharing resources such as memory and file handles. Threads within a process can run concurrently on different CPU cores, enabling efficient parallel execution of tasks.<\/p>\n\n\n\n

1.2 Concurrency vs. Parallelism<\/h3>\n\n\n\n

Concurrency refers to the ability of a program to manage multiple tasks simultaneously, while parallelism is the actual simultaneous execution of these tasks. Concurrency can be achieved without parallelism, as in the case of a single-core processor, where tasks are interleaved.<\/p>\n\n\n\n

1.3 Synchronization<\/h3>\n\n\n\n

Thread synchronization is crucial for preventing data races and ensuring the correctness of multithreaded programs. This can be achieved using various techniques, such as mutexes, locks, and condition variables.<\/p>\n\n\n\n

2. C++11: Standard Threading Library<\/h2>\n\n\n\n

C++11 introduced the standard threading library, which provided an extensive set of tools and utilities to manage threads, synchronization primitives, and thread-local storage.<\/p>\n\n\n\n

2.1 Creating and Managing Threads<\/h3>\n\n\n\n

The std::thread<\/code><\/strong> class in C++11 allows for the creation and management of threads. To create a new thread, simply instantiate the std::thread<\/code><\/strong> object with a function or a callable object. The newly created thread starts executing the provided function. To wait for the completion of a thread, use the join()<\/code><\/strong> method.<\/p>\n\n\n

#include<\/span> <iostream><\/span><\/span>\n#include<\/span> <thread><\/span><\/span>\n\nvoid<\/span> my_function<\/span>()<\/span> <\/span>{\n  std<\/span>::cout<\/span> << \"Hello from my_function!\"<\/span> << std<\/span>::endl<\/span>;\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n  std<\/span>::thread t<\/span>(my_function)<\/span><\/span>;\n  t.join();\n  return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
2.2 Synchronization Primitives<\/h3>\n\n\n\n
2.2.1 Mutexes<\/h4>\n\n\n\n
A mutex<\/code><\/strong> (short for “mutual exclusion”) is a synchronization primitive used to ensure that only one thread can access a shared resource at a time. In C++11, the std::mutex<\/code><\/strong> class provides a basic mutex<\/code><\/strong> implementation.<\/p>\n\n\n
#include<\/span> <iostream><\/span><\/span>\n#include<\/span> <mutex><\/span><\/span>\n#include<\/span> <thread><\/span><\/span>\n\nstd<\/span>::mutex mtx;\n\nvoid<\/span> print_hello<\/span>()<\/span> <\/span>{\n  std<\/span>::unique_lock<std<\/span>::mutex> lock<\/span>(mtx)<\/span><\/span>;\n  std<\/span>::cout<\/span> << \"Hello, world!\"<\/span> << std<\/span>::endl<\/span>;\n  lock.unlock();\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n  std<\/span>::thread t1<\/span>(print_hello)<\/span><\/span>;\n  std<\/span>::thread t2<\/span>(print_hello)<\/span><\/span>;\n  t1.join();\n  t2.join();\n  return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
2.2.2 Locks<\/h4>\n\n\n\n
C++11 provides various lock classes, such as std::lock_guard<\/code><\/strong> and std::unique_lock<\/code><\/strong>, which can be used to manage the ownership and locking of mutexes.<\/p>\n\n\n\n
2.2.3 Condition Variables<\/h4>\n\n\n\n
A condition variable is a synchronization primitive used to block a thread until a particular condition is met. C++11 provides the std::condition_variable<\/strong><\/code> class for this purpose.<\/p>\n\n\n\n
2.3 Thread-Local Storage<\/h3>\n\n\n\n
Thread-local storage (TLS) allows each thread to have its own instance of a variable, ensuring that the value of the variable is not shared between threads. C++11 introduces the thread_local<\/code><\/strong> keyword for defining thread-local variables.<\/p>\n\n\n
#include<\/span> <iostream><\/span><\/span>\n#include<\/span> <thread><\/span><\/span>\n\nthread_local<\/span> int<\/span> counter = 0<\/span>;\n\nvoid<\/span> increment_counter<\/span>()<\/span> <\/span>{\n  ++counter;\n  std<\/span>::cout<\/span> << \"Counter: \"<\/span> << counter << std<\/span>::endl<\/span>;\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n  std<\/span>::thread t1<\/span>(increment_counter)<\/span><\/span>;\n  std<\/span>::thread t2<\/span>(increment_counter)<\/span><\/span>;\n  t1.join();\n  t2.join();\n  return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
3. C++14 and C++17: Enhancements and New Features<\/h2>\n\n\n\n
C++14 and C++17 brought several improvements and new features to the world of multithreading, making it even more powerful and easier to use.<\/p>\n\n\n\n
3.1 C++14: Shared Locks<\/h3>\n\n\n\n
C++14 introduced the std::shared_timed_mutex<\/code><\/strong> and std::shared_lock<\/code><\/strong> classes, allowing for shared ownership of a mutex<\/code><\/strong>. This is particularly useful when multiple threads need to read a shared resource but only one thread can modify it.<\/p>\n\n\n
#include<\/span> <iostream><\/span><\/span>\n#include<\/span> <shared_mutex><\/span><\/span>\n#include<\/span> <thread><\/span><\/span>\n\nstd<\/span>::shared_timed_mutex mtx;\nint<\/span> shared_data = 0<\/span>;\n\nvoid<\/span> reader<\/span>()<\/span> <\/span>{\n  std<\/span>::shared_lock<std<\/span>::shared_timed_mutex> lock<\/span>(mtx)<\/span><\/span>;\n  std<\/span>::cout<\/span> << \"Reader: shared_data = \"<\/span> << shared_data << std<\/span>::endl<\/span>;\n}\n\nvoid<\/span> writer<\/span>()<\/span> <\/span>{\n  std<\/span>::unique_lock<std<\/span>::shared_timed_mutex> lock<\/span>(mtx)<\/span><\/span>;\n  ++shared_data;\n  std<\/span>::cout<\/span> << \"Writer: shared_data = \"<\/span> << shared_data << std<\/span>::endl<\/span>;\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n  std<\/span>::thread r1<\/span>(reader)<\/span><\/span>;\n  std<\/span>::thread r2<\/span>(reader)<\/span><\/span>;\n  std<\/span>::thread w1<\/span>(writer)<\/span><\/span>;\n  r1.join();\n  r2.join();\n  w1.join();\n  return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
3.2 C++17: Parallel Algorithms<\/h3>\n\n\n\n
C++17 introduced parallel algorithms as part of the standard library, allowing developers to leverage parallelism with ease. These algorithms operate on standard containers and are designed to automatically parallelize their execution when possible. Developers can specify the desired level of parallelism using execution policies, such as std::execution::seq<\/code><\/strong>, std::execution::par<\/code><\/strong>, and std::execution::par_unseq<\/code><\/strong>.<\/p>\n\n\n
#include<\/span> <algorithm><\/span><\/span>\n#include<\/span> <execution><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n  std<\/span>::vector<\/span><int<\/span>> data{5<\/span>, 2<\/span>, 8<\/span>, 1<\/span>, 3<\/span>, 6<\/span>, 4<\/span>, 7<\/span>};\n  std<\/span>::sort(std<\/span>::execution::par, data.begin(), data.end());\n\n  for<\/span> (const<\/span> auto<\/span>& value : data) {\n    std<\/span>::cout<\/span> << value << \" \"<\/span>;\n  }\n  std<\/span>::cout<\/span> << std<\/span>::endl<\/span>;\n\n  return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
4. Best Practices for Modern C++ Multithreading<\/h2>\n\n\n\n
4.1 Avoid Global Variables<\/h3>\n\n\n\n
Global variables can lead to data races and synchronization issues. Whenever possible, use local variables or thread-local storage instead.<\/p>\n\n\n\n
4.2 Minimize Lock Contention<\/h3>\n\n\n\n
Lock contention occurs when multiple threads compete for the same lock. To minimize lock contention, minimize the time spent holding locks and avoid nested locking.<\/p>\n\n\n\n
4.3 Use Fine-Grained Locks<\/h3>\n\n\n\n
Instead of using a single lock for an entire data structure, use multiple fine-grained locks to protect smaller parts of the structure. This allows for greater concurrency and reduces lock contention.<\/p>\n\n\n\n
4.4 Use Lock-Free Data Structures<\/h3>\n\n\n\n
Lock-free data structures can provide better performance and scalability in certain scenarios. Consider using lock-free data structures, such as those provided by the C++ Concurrency TS, when appropriate.<\/p>\n\n\n\n
Example Exercise: Multithreaded Web Crawler<\/h2>\n\n\n\n
Objective<\/strong>: Create a simple multithreaded web crawler that downloads and extracts URLs from web pages using modern C++ multithreading techniques.<\/p>\n\n\n\n
Task Description<\/strong>: Implement a web crawler that starts with a seed URL, fetches the content of the page, extracts all the URLs present in the page, and continues crawling the extracted URLs. The crawler should use multiple threads to download and process web pages concurrently. Additionally, the crawler should store visited URLs to avoid revisiting the same pages.<\/p>\n\n\n\n
To achieve this, we’ll use the following libraries:<\/p>\n\n\n\n
    \n
  • libcurl<\/strong> for fetching web pages.<\/li>\n\n\n\n
  • htmlcxx<\/strong> for parsing HTML and extracting URLs.<\/li>\n\n\n\n
  • C++ standard threading library for multithreading.<\/li>\n<\/ul>\n\n\n\n
    Source code:<\/p>\n\n\n
    #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <string><\/span><\/span>\n#include<\/span> <unordered_set><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <queue><\/span><\/span>\n#include<\/span> <mutex><\/span><\/span>\n#include<\/span> <thread><\/span><\/span>\n#include<\/span> <condition_variable><\/span><\/span>\n#include<\/span> <curl\/curl.h><\/span><\/span>\n#include<\/span> <htmlcxx\/html\/ParserDom.h><\/span><\/span>\n\n\/\/ Global variables<\/span>\nstd<\/span>::unordered_set<\/span><std<\/span>::string<\/span>> visited_urls;\nstd<\/span>::queue<\/span><std<\/span>::string<\/span>> urls_to_visit;\nstd<\/span>::mutex mtx;\nstd<\/span>::condition_variable cv;\n\n\/\/ CURL write callback to store fetched content<\/span>\nsize_t<\/span> write_callback<\/span>(void<\/span>* contents, size_t<\/span> size, size_t<\/span> nmemb, void<\/span>* userp)<\/span> <\/span>{\n    ((std<\/span>::string<\/span>*)userp)->append((char<\/span>*)contents, size * nmemb);\n    return<\/span> size * nmemb;\n}\n\n\/\/ Fetch the content of the given URL<\/span>\nstd<\/span>::string<\/span> fetch_url<\/span>(const<\/span> std<\/span>::string<\/span>& url)<\/span> <\/span>{\n    std<\/span>::string<\/span> content;\n    CURL* curl = curl_easy_init();\n\n    if<\/span> (curl) {\n        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());\n        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);\n        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &content);\n        curl_easy_perform(curl);\n        curl_easy_cleanup(curl);\n    }\n\n    return<\/span> content;\n}\n\n\/\/ Extract URLs from the content of a web page<\/span>\nstd<\/span>::vector<\/span><std<\/span>::string<\/span>> extract_urls<\/span>(const<\/span> std<\/span>::string<\/span>& content)<\/span> <\/span>{\n    htmlcxx::HTML::ParserDom parser;\n    tree<htmlcxx::HTML::Node> dom = parser.parseTree(content);\n\n    std<\/span>::vector<\/span><std<\/span>::string<\/span>> urls;\n\n    for<\/span> (auto<\/span> it = dom.begin(); it != dom.end(); ++it) {\n        if<\/span> (it->tagName() == \"a\"<\/span>) {\n            it->parseAttributes();\n            std<\/span>::string<\/span> url = it->attribute(\"href\"<\/span>).second;\n            if<\/span> (!url.empty()) {\n                urls.push_back(url);\n            }\n        }\n    }\n\n    return<\/span> urls;\n}\n\n\/\/ Crawl function that runs in multiple threads<\/span>\nvoid<\/span> crawl<\/span>()<\/span> <\/span>{\n    while<\/span> (true<\/span>) {\n        std<\/span>::unique_lock<std<\/span>::mutex> lock<\/span>(mtx)<\/span><\/span>;\n        cv.wait(lock, []{ return<\/span> !urls_to_visit.empty(); });\n\n        std<\/span>::string<\/span> url = urls_to_visit.front();\n        urls_to_visit.pop();\n        lock.unlock();\n\n        if<\/span> (visited_urls.find(url) == visited_urls.end()) {\n            std<\/span>::string<\/span> content = fetch_url(url);\n            std<\/span>::vector<\/span><std<\/span>::string<\/span>> extracted_urls = extract_urls(content);\n\n            lock.lock();\n            visited_urls.insert(url);\n            for<\/span> (const<\/span> auto<\/span>& extracted_url : extracted_urls) {\n                if<\/span> (visited_urls.find(extracted_url) == visited_urls.end()) {\n                    urls_to_visit.push(extracted_url);\n                }\n            }\n            lock.unlock();\n\n            std<\/span>::cout<\/span> << \"Visited URL: \"<\/span> << url << std<\/span>::endl<\/span>;\n        }\n\n        cv.notify_one();\n    }\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    \/\/ Initialize CURL<\/span>\n    curl_global_init(CURL_GLOBAL_DEFAULT);\n\n    \/\/ Seed URL<\/span>\n    std<\/span>::string<\/span> seed_url = \"https:\/\/www.example.com\"<\/span>;\n    urls_to_visit.push(seed_url);\n\n    \/\/ Number of threads for the web crawler<\/span>\n    const<\/span> unsigned<\/span> int<\/span> num_threads = 4<\/span>;\n    std<\/span>::vector<\/span><std<\/span>::thread> threads;\n\n    \/\/ Create and start the threads<\/span>\n    for<\/span> (unsigned<\/span> int<\/span> i = 0<\/span>; i < num_threads; ++i) {\n        threads.emplace_back(crawl);\n    }\n\n    \/\/ Set a limit for the number of visited URLs<\/span>\n    const<\/span> size_t<\/span> max_visited_urls = 100<\/span>;\n\n    \/\/ Wait for the crawler to finish<\/span>\n    while<\/span> (true<\/span>) {\n        std<\/span>::unique_lock<std<\/span>::mutex> lock<\/span>(mtx)<\/span><\/span>;\n        cv.wait(lock, [&]{ return<\/span> visited_urls.size() >= max_visited_urls; });\n        break<\/span>;\n    }\n\n    \/\/ Stop the threads and wait for them to finish<\/span>\n    for<\/span> (auto<\/span>& thread : threads) {\n        if<\/span> (thread.joinable()) {\n            thread.detach();\n        }\n    }\n\n    \/\/ Cleanup CURL<\/span>\n    curl_global_cleanup();\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    This example demonstrates a multithreaded web crawler that fetches web pages, extracts URLs, and continues crawling the extracted URLs. The program uses the C++ standard threading library to manage threads, the libcurl library to fetch web pages, and the htmlcxx<\/strong> library to parse HTML and extract URLs. To keep track of visited URLs and URLs to be visited, the crawler uses a std::unordered_set<\/code><\/strong> and a std::queue<\/strong><\/code>, respectively, with proper synchronization using std::mutex<\/code><\/strong> and std::condition_variable<\/code><\/strong>.<\/p>\n\n\n\n
    Note that this example is for illustrative purposes and is not intended for use in production environments. A production-ready web crawler would require proper error handling, URL normalization, URL filtering, and adherence to the robots.txt standard, among other considerations.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Concurrency and multithreading have become increasingly important in the world of software development as the need to leverage multiple cores and processors for improved performance and efficiency grows. With the advent of modern C++, developers now have access to a robust set of multithreading tools and techniques that can help them create more efficient and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[9,4],"tags":[],"class_list":["post-191","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nModern C++ Multithreading Techniques<\/title>\n<meta name=\"description\" content=\"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Modern C++ Multithreading Techniques\" \/>\n<meta property=\"og:description\" content=\"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-04-06T09:09:47+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:22:30+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Modern C++ Multithreading Techniques: Unlocking the Power of Concurrent Programming\",\"datePublished\":\"2023-04-06T09:09:47+00:00\",\"dateModified\":\"2023-08-23T16:22:30+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/\"},\"wordCount\":891,\"commentCount\":0,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/\",\"name\":\"Modern C++ Multithreading Techniques\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-04-06T09:09:47+00:00\",\"dateModified\":\"2023-08-23T16:22:30+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/modern-cpp-multithreading-techniques\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"C++\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/cplusplus\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Modern C++ Multithreading Techniques: Unlocking the Power of Concurrent Programming\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Modern C++ Multithreading Techniques","description":"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/","og_locale":"en_US","og_type":"article","og_title":"Modern C++ Multithreading Techniques","og_description":"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17","og_url":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/","article_published_time":"2023-04-06T09:09:47+00:00","article_modified_time":"2023-08-23T16:22:30+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Modern C++ Multithreading Techniques: Unlocking the Power of Concurrent Programming","datePublished":"2023-04-06T09:09:47+00:00","dateModified":"2023-08-23T16:22:30+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/"},"wordCount":891,"commentCount":0,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/","url":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/","name":"Modern C++ Multithreading Techniques","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-04-06T09:09:47+00:00","dateModified":"2023-08-23T16:22:30+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"This article aims to delve deep into modern C++ multithreading techniques, focusing on the features introduced by the C++11, C++14, and C++17","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/modern-cpp-multithreading-techniques\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"C++","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/cplusplus\/"},{"@type":"ListItem","position":4,"name":"Modern C++ Multithreading Techniques: Unlocking the Power of Concurrent Programming"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/191","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=191"}],"version-history":[{"count":5,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/191\/revisions"}],"predecessor-version":[{"id":747,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/191\/revisions\/747"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=191"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=191"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=191"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}