C++是一种强大的编程语言，具有许多功能和特性，其中之一就是多线程编程。在多线程编程中，可能会有多个线程访问相同的资源和变量，这就需要使用同步和互斥机制来保护共享数据的完整性。本文将介绍在C++多线程中如何访问共享资源并回调函数。

1.使用互斥锁

互斥锁是最常用的同步机制之一，它将临界区封装在一起，只允许一个线程访问共享资源。在C++中，可以使用std::mutex类来实现互斥锁。以下是一个简单的例子：

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex;
int sharedData = 0;
void doSomething(int id) {
 for(int i = 0; i < 5; i++) {
  std::unique_lock<std::mutex> lock(mutex); //获取锁
  sharedData++;
  std::cout << "Thread " << id << " adds 1 to sharedData, sharedData = " << sharedData << std::endl;
  lock.unlock(); //释放锁
 }
}
int main() {
 std::thread t1(doSomething, 1);
 std::thread t2(doSomething, 2);
 t1.join();
 t2.join();
 return 0;
}

在这个例子中，使用std::mutex类实现了互斥锁，使用unique_lock获取和释放锁，并在临界区内访问共享资源。

2.使用条件变量

条件变量是一种同步机制，允许线程按照特定的条件等待或者唤醒。在C++中，可以使用std::condition_variable类实现条件变量。以下是一个简单的例子：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mutex;
std::condition_variable cond;
int sharedData = 0;
bool dataReady = false;
void doSomething(int id) {
 for(int i = 0; i < 5; i++) {
  std::unique_lock<std::mutex> lock(mutex);
  while(!dataReady) { //等待条件变量
   cond.wait(lock);
  }
  sharedData++;
  std::cout << "Thread " << id << " adds 1 to sharedData, sharedData = " << sharedData << std::endl;
  dataReady = false;
  lock.unlock();
  cond.notify_one(); //唤醒等待条件变量的线程
 }
}
void sendData() {
 for(int i = 0; i < 5; i++) {
  std::unique_lock<std::mutex> lock(mutex);
  while(dataReady) { //等待条件变量
   cond.wait(lock);
  }
  std::cout << "Main thread sends data" << std::endl;
  dataReady = true;
  lock.unlock();
  cond.notify_one(); //唤醒等待条件变量的线程
 }
}
int main() {
 std::thread t1(doSomething, 1);
 std::thread t2(doSomething, 2);
 sendData();
 t1.join();
 t2.join();
 return 0;
}

在这个例子中，使用std::condition_variable类实现了条件变量，使用wait和notify_one等待和唤醒线程，并在临界区内访问共享资源。

3.回调函数

回调函数是一种常用的编程技术，它允许函数将另一个函数作为参数，并在适当的时候调用该函数。在多线程编程中，回调函数可以用于在线程完成某个任务后通知另一个线程。以下是一个简单的例子：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
std::mutex mutex;
std::condition_variable cond;
bool taskDone = false;
void doTask(std::function<void()> callback) {
 std::cout << "Task starts" << std::endl;
 std::this_thread::sleep_for(std::chrono::seconds(2)); //模拟任务执行
 std::unique_lock<std::mutex> lock(mutex);
 taskDone = true;
 callback(); //执行回调函数
}
void callback() {
 std::unique_lock<std::mutex> lock(mutex);
 std::cout << "Callback starts" << std::endl;
 taskDone = true;
}
int main() {
 std::thread t(doTask, callback);
 std::unique_lock<std::mutex> lock(mutex);
 while(!taskDone) {
  cond.wait(lock);
 }
 std::cout << "Main thread finishes" << std::endl;
 t.join();
 return 0;
}

在这个例子中，使用std::function类实现了回调函数，在doTask函数中执行任务，并在任务完成后执行回调函数。

综上所述，使用互斥锁和条件变量来同步线程，同时使用回调函数来通知线程完成任务是在C++多线程中访问共享资源并回调函数的常用方法。开发人员可以根据具体的需求选择适当的同步机制和回调函数实现。

相似文章
• C++多线程中静态变量的访问问题
  在C++多线程编程中，静态变量的访问问题是一个需要注意的问题。静态变量是一个非常常见的变量类型，在代码中经常用来存储一些全局的信息或者某些对象的状态，其生命周期往往伴随整个程序的运行过程。
  
  
• C++ 多线程 Socket 编程
  C++
  
  
• C++多线程共享变量：实现线程同步和互斥的方法
  在C++程序中，多线程共享变量是一种常见的情况。但是，当多个线程同时读写变量时，就有可能出现数据竞争。为了避免这种情况，需要使用线程同步和互斥的方法。
  
  
• C++多线程相比硬件线程的优势
  C++是一种高级编程语言，其支持多线程编程，这意味着在一个C++程序中可以同时执行多个任务，从而提高程序的效率。在这种情况下，C++多线程相比硬件线程具有许多优势。
  
  
• C++多线程下的条件变量使用
  条件变量是在多线程编程中用于实现线程等待和唤醒的一种同步机制。在C++多线程编程中，条件变量通常与互斥量一起使用以实现线程同步。本文将介绍C++多线程中条件变量的使用方法。
  
  
• C++多线程生产者消费者：实现并发编程的高效生产与消费
  在现代计算机体系结构中，多线程编程已成为必不可少的一部分。由于多线程编程能够在一定程度上提高计算机系统的硬件资源利用率，其在并发编程中的应用愈发广泛。而在多线程编程中，生产者消费者模型是一种常见的并发编程模型，可以高效地实现数据的生产和消费
  
  
• C++ 多线程 Socket 编程
  C++
  
  
• C++多线程同步方法详解
  C++是一门流行的编程语言，拥有强大的多线程功能。在多线程编程中，同步非常重要，它可以防止产生竞态条件，保证线程的安全。本文将详细介绍C++多线程同步的方法。
  
  

友情链接
• 网站定制开发
• 帮你发
• 小蓄群站获客
• 雅圣洁家政