Corak kejuruteraan dan reka bentuk dalam pengaturcaraan serentak C++?

Pengaturcaraan serentak dalam C++ melibatkan sumber yang dikongsi dan operasi yang disegerakkan, memerlukan corak kejuruteraan dan reka bentuk untuk menyelesaikan cabaran. Mod kejuruteraan termasuk multithreading, proses, kumpulan benang, semaphore dan operasi atom untuk pengurusan benang yang cekap. Corak reka bentuk termasuk baris gilir pengeluar-pengguna, kunci pembaca-penulis, pengelakan kebuntuan, pencegahan kelaparan dan pecah-dan-takluk untuk menyelaraskan akses dan pemprosesan data. Corak ini boleh digunakan untuk masalah dunia sebenar seperti pemprosesan imej dan perkhidmatan pembalakan untuk melaksanakan program serentak yang cekap. . C++ menyediakan pelbagai corak kejuruteraan dan reka bentuk untuk menyelesaikan cabaran ini, yang artikel ini akan meneroka secara mendalam.

Mod Projek

Berbilang benang:

Lakukan berbilang tugas serentak untuk meningkatkan prestasi.

Proses:

Persekitaran pelaksanaan terpencil yang berkongsi sumber sistem pengendalian dengan proses lain.

Kolam Benang: Himpunan benang yang telah diperuntukkan terlebih dahulu untuk mengurangkan overhed penciptaan benang.

• Semaphore: Mekanisme penyegerakan untuk mengehadkan akses serentak kepada sumber yang dikongsi.
• Kendalian Atom: Lakukan operasi atom pada satu lokasi memori dalam persekitaran satu benang.
• Kes praktikal:
• Pertimbangkan untuk menggunakan kumpulan benang untuk pemprosesan imej. Pembacaan dan pemprosesan imej boleh diedarkan antara berbilang benang dalam kumpulan.

  #include <vector>
  #include <future>
  #include <thread>
  
  void process_image(const std::string& filename) {
    // Image processing logic here
  }
  
  int main() {
    // 创建线程池
    std::vector<std::thread> pool;
    int num_threads = 8;
    for (int i = 0; i < num_threads; ++i) {
      pool.push_back(std::thread([] {
        // 该线程将执行 image_processing()
      }));
    }
  
    // 提交任务到池
    std::vector<std::future<void>> results;
    std::vector<std::string> filenames = {"image1.jpg", "image2.jpg", ...};
    for (const auto& filename : filenames) {
      results.push_back(std::async(std::launch::async, process_image, filename));
    }
  
    // 等待任务完成
    for (auto& result : results) {
      result.wait();
    }
  
    // 关闭线程池
    for (auto& thread : pool) {
      thread.join();
    }
  
    return 0;
  }

Corak Reka Bentuk

Barisan Pengeluar-Pengguna:

Pengabstrakan baris gilir yang membolehkan pengeluar menulis data ke baris gilir dan pengguna membaca data daripada baris gilir.

Kunci Pembaca-Penulis:

Mekanisme penyegerakan yang mengehadkan akses baca dan tulis serentak kepada data yang dikongsi.

Mengelakkan Kebuntuan: Mencegah kebuntuan melalui pemerolehan sumber yang teliti dan perintah pelepasan.

• Cegah kebuluran: Pastikan setiap utas mempunyai peluang untuk mendapatkan sumber dan mengelakkan beberapa utas daripada kelaparan untuk jangka masa yang lama.
• Bahagi dan Takluk: Pecahkan masalah kepada subtugas serentak yang lebih kecil dan kemudian gabungkan hasilnya.
• Kes praktikal:
• Pertimbangkan untuk menggunakan baris gilir pengeluar-pengguna untuk melaksanakan perkhidmatan log. Benang pengeluar mencatat peristiwa, manakala benang pengguna memproses log dan menulisnya ke fail.

  #include <queue>
  #include <mutex>
  #include <thread>
  
  std::queue<std::string> log_queue;
  std::mutex log_queue_mutex;
  
  void write_log(const std::string& entry) {
    std::lock_guard<std::mutex> lock(log_queue_mutex);
    log_queue.push(entry);
  }
  
  void process_logs() {
    while (true) {
      std::string entry;
      {
        std::lock_guard<std::mutex> lock(log_queue_mutex);
        if (log_queue.empty()) {
          // 队列为空时，防止忙等待
          std::this_thread::sleep_for(std::chrono::milliseconds(1));
          continue;
        }
        entry = log_queue.front();
        log_queue.pop();
      }
      // 处理日志项
    }
  }
  
  int main() {
    // 创建生产者线程
    std::thread producer(write_log, "Log entry 1");
    // 创建消费者线程
    std::thread consumer(process_logs);
  
    producer.join();
    consumer.join();
  
    return 0;
  }

Kesimpulan
• Dengan mengguna pakai corak kejuruteraan dan reka bentuk yang sesuai, pengaturcara C++ boleh melaksanakan program serentak dengan berkesan, memaksimumkan prestasi dan mengurangkan isu ketekalan data.

Atas ialah kandungan terperinci Corak kejuruteraan dan reka bentuk dalam pengaturcaraan serentak C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!