Keselamatan benang dalam pengurusan memori C++

Pengurusan memori selamat benang dalam C++ memastikan integriti data dengan memastikan tiada kerosakan data atau keadaan perlumbaan berlaku apabila berbilang benang mengakses data dikongsi secara serentak. Takeaway Utama: Gunakan petunjuk pintar seperti std::shared_ptr dan std::unique_ptr untuk peruntukan memori dinamik selamat benang. Gunakan mutex (seperti std::mutex) untuk melindungi data kongsi daripada akses serentak oleh berbilang benang. Data yang dikongsi dan kaunter berbilang benang digunakan dalam kes praktikal untuk menunjukkan aplikasi pengurusan ingatan selamat benang.

Keselamatan benang dalam pengurusan memori C++

Keselamatan benang bermakna apabila berbilang rangkaian mengakses data kongsi pada masa yang sama, tidak akan berlaku sebarang kerosakan data atau keadaan perlumbaan. Dalam C++, pengurusan memori adalah penting apabila menggunakan multithreading kerana ia melibatkan data yang dikongsi dan akses yang disegerakkan.

Peruntukan Memori Dinamik

Dalam C++, gunakan operator baharu dan delete untuk peruntukan memori dinamik. Walau bagaimanapun, pengendali ini sendiri tidak selamat untuk benang: new 和 delete 运算符进行动态内存分配。然而，这些运算符本身不是线程安全的：

int *ptr = new int;
delete ptr;

如果多个线程同时使用此代码，则可能导致释放后使用（use-after-free）问题或双重释放问题。

线程安全的动态内存分配

为了确保线程安全的动态内存分配，C++ 标准库提供了一些线程安全的替代方案：

• std::shared_ptr：一种智能指针，它可以安全地同时被多个线程共享。它使用引用计数来跟踪共享程度，并在不再有线程引用指针时释放内存。
• std::unique_ptr：一种智能指针，它只能被一个线程拥有。它在对象不再需要时立即释放内存。

示例：线程安全共享资源

考虑一个包含共享资源（例如统计数据）的类：

class SharedData {
public:
  std::mutex mtx; // 互斥锁
  int count = 0;

  void increment() {
    std::lock_guard<std::mutex> lock(mtx); // 获取互斥锁
    ++count;
  }
};

该类使用互斥锁 mtx 来保护共享数据，从而确保当多个线程同时访问 increment() 方法时，计数不会被破坏。

实战案例：多线程计数器

以下是一个实战案例，演示如何使用线程安全的动态内存分配和同步：

#include <iostream>
#include <thread>
#include <vector>
#include <memory>

std::shared_ptr<SharedData> sharedData = std::make_shared<SharedData>();

void incrementThread() {
  for (int i = 0; i < 1000000; ++i) {
    sharedData->increment();
  }
}

int main() {
  std::vector<std::thread> threads;
  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(incrementThread);
  }

  for (auto &thread : threads) {
    thread.join();
  }

  std::cout << "Final count: " << sharedData->count << std::endl;

  return 0;
}

这个程序创建了共享数据并将其作为 std::shared_ptrrrreee

Jika berbilang benang menggunakan kod ini pada masa yang sama, ia boleh menyebabkan masalah bebas penggunaan atau masalah bebas dua kali. 🎜🎜Peruntukan memori dinamik selamat benang🎜🎜Untuk memastikan peruntukan memori dinamik selamat benang, perpustakaan standard C++ menyediakan beberapa alternatif selamat benang: 🎜

• std::shared_ptr: A penunjuk pintar yang boleh dikongsi dengan selamat oleh berbilang rangkaian pada masa yang sama. Ia menggunakan pengiraan rujukan untuk menjejaki sejauh mana perkongsian dan membebaskan memori apabila tiada benang merujuk penuding lagi.
• std::unique_ptr: Penunjuk pintar yang hanya boleh dimiliki oleh satu urutan. Ia membebaskan memori sebaik sahaja objek tidak diperlukan lagi.

🎜Contoh: Sumber perkongsian selamat benang🎜🎜Pertimbangkan kelas yang mengandungi sumber dikongsi (seperti statistik): 🎜rrreee🎜Kelas ini menggunakan mtx mutex untuk melindungi data kongsi untuk memastikan kiraan tidak rosak apabila berbilang urutan mengakses kaedah increment() secara serentak. 🎜🎜Kes praktikal: Kaunter berbilang benang🎜🎜Berikut ialah kes praktikal yang menunjukkan cara menggunakan peruntukan memori dinamik selamat benang dan penyegerakan: 🎜rrreee🎜Atur cara ini mencipta data kongsi dan menggunakannya sebagai std::shared_ptr rujukan. Ia kemudian mencipta 10 utas, setiap satunya menambah pembilang 1,000,000 kali ganda. Benang utama menunggu semua benang selesai dan akhirnya mencetak kiraan akhir. 🎜

Atas ialah kandungan terperinci Keselamatan benang dalam pengurusan memori C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!