Скачать или смотреть How to Prevent Thread Interference in C with Pthreads

Learn how to effectively manage threads in C using pthreads to avoid interference and ensure safe parallel execution of your code.
---
This video is based on the question https://stackoverflow.com/q/65703111/ asked by the user 'overworked student' ( https://stackoverflow.com/u/14633919/ ) and on the answer https://stackoverflow.com/a/65703249/ provided by the user 'Maxim Egorushkin' ( https://stackoverflow.com/u/412080/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: pthreads in C: How can I stop the threads from interfering with each other?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Prevent Thread Interference in C with Pthreads

If you're new to multithreading in C, you might encounter issues where threads interfere with each other, leading to unexpected behavior. This is particularly common when multiple threads are accessing shared variables. In this post, we will address a specific example of this problem and explain how to solve it using pthreads.

Understanding the Problem

Consider the following scenario: you have a program that creates six different threads, each tasked with outputting a unique number. Although the threads can run in any order, they should each run only once. Here’s what the output might look like:

[[See Video to Reveal this Text or Code Snippet]]

However, if you run your program, you might see outputs like these:

[[See Video to Reveal this Text or Code Snippet]]

or

[[See Video to Reveal this Text or Code Snippet]]

This erratic output indicates that the threads are interfering with each other. The problem stems from the fact that each thread is accessing the same variable (apple_num), which is being modified by the main thread. As threads start asynchronously at different times, there's no guarantee which value of apple_num will be read by which thread, leading to inconsistent results.

The Solution: Passing Unique Copies of Variables

To prevent this interference, each thread must receive a copy of its own unique variable rather than a reference to the shared apple_num. Below are the steps to implement this solution effectively.

Step 1: Modify the Thread Function Signature

Instead of using int * for your thread function, use (void *) to allow more flexibility in what data you can pass. Your thread function will look like this:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Create Individual Copies for Each Thread

During thread creation, provide each thread with a unique copy of apple_num. The following example demonstrates how to create a unique context for each thread using dynamic memory allocation:

[[See Video to Reveal this Text or Code Snippet]]

Important Notes on Memory Management

Dynamic Allocation: Using malloc allows each thread to have its own copy of apple_num, preventing interference. However, remember to use free to avoid memory leaks.

Automatic Variables: If you want to use stack variables instead of heap allocation, ensure the variable remains unchanged and in scope when accessed by threads.

Conclusion

By ensuring that each thread receives its own distinct variable, you can effectively prevent threads from interfering with each other in your C programs using pthreads. This not only improves the readability of your code but also enhances its reliability and predictability. Happy coding, and enjoy the world of multithreading!