C++ Concurrent Programming: How to manage resource allocation in parallel threads?

In multi-threaded programs, C uses mutex locks and atomic types to ensure correct access of threads to shared resources. Mutex lock: The std::mutex class creates a mutex lock, allowing only one thread to access shared resources at a time, preventing data races. Atomic type: std::atomic provides atomic operations to prevent multiple threads from modifying the same variable at the same time, ensuring thread safety.

C Concurrent Programming: Managing Resource Allocation in Parallel Threads

In multi-threaded programming, managing resource allocation is important to prevent data competition and ensuring program correctness is crucial. C provides several synchronization mechanisms for resource allocation, including mutexes and atomic types.

1. Mutex lock

Mutex lock is a synchronization mechanism that allows only one thread to access shared resources at a time. In C, you can use the std::mutex class to create a mutex.

Code example:

std::mutex mtx;

void thread_function() {
  std::lock_guard<std::mutex> guard(mtx);
  // 对共享资源进行操作
}

In this example, std::lock_guard is a RAII (resource acquisition is initialization) wrapper, which The mutex is locked for the lifetime of the function scope.

2. Atomic types

Atomic types are thread-safe built-in types that can perform atomic operations. They prevent multiple threads from modifying the same variable at the same time, thereby avoiding data races. The C standard library provides some atomic types, such as std::atomic<T>.

Code example:

std::atomic<int> counter;

void thread_function() {
  counter++; // 执行原子增量操作
}

Practical case

Consider a producer-consumer problem, in which the producer thread generates data, while the consumer thread consumes the data. The resource is a shared queue that needs to be protected by a mutex to prevent data races.

Code example:

std::mutex mtx;
std::queue<int> queue;

void producer_thread() {
  while (true) {
    std::lock_guard<std::mutex> guard(mtx);
    queue.push(rand());
  }
}

void consumer_thread() {
  while (true) {
    std::lock_guard<std::mutex> guard(mtx);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

int main() {
  std::thread t1(producer_thread);
  std::thread t2(consumer_thread);
  t1.join();
  t2.join();
  return 0;
}

In this example, a mutex is used to protect the shared queue to prevent producer and consumer threads from accessing the queue at the same time.

The above is the detailed content of C++ Concurrent Programming: How to manage resource allocation in parallel threads?. For more information, please follow other related articles on the PHP Chinese website!