Cマルチスレッドと並行性：並列プログラミングのマスタリング

cマルチスレッドと同時プログラミングのコア概念には、スレッドの作成と管理、同期と相互排除、条件付き変数、スレッドプーリング、非同期プログラミング、一般的なエラーとデバッグ技術、パフォーマンスの最適化とベストプラクティスが含まれます。 1）STD ::スレッドクラスを使用してスレッドを作成します。この例は、スレッドが完了する方法を作成し、待つ方法を示しています。 2）共有リソースを保護し、データ競争を回避するために、STD :: MutexおよびSTD :: LOCK_GUARDを使用するための同期と相互除外。 3）条件変数は、std :: condition_variableを介したスレッド間の通信と同期を実現します。 4）スレッドプールの例は、スレッドプールクラスを使用してタスクを並行して処理して効率を向上させる方法を示しています。 5）非同期プログラミングは、std :: asyncおよびstd :: futureを使用して実装されます。この例は、非同期タスクのスタートアップと結果の獲得を示しています。 6）一般的なエラーには、データ競争、デッドロック、リソースの漏れ、デバッグスキルには、ロックと原子操作の使用、デバッグツールが含まれます。 7）パフォーマンスの最適化の提案には、スレッドプールの使用、STD :: AtomicおよびRealance Locksの使用が含まれ、プログラムのパフォーマンスとセキュリティを改善します。

導入

現代のプログラミングでは、マルチスレッドと同時プログラミングがプログラムのパフォーマンスと応答性を向上させるための重要な技術となっています。高性能コンピューティングアプリケーションを開発している場合でも、応答性の高いユーザーインターフェイスを構築している場合でも、Cでのマルチスレッドと同時プログラミングのマスタリングは不可欠なスキルです。この記事では、Cマルチスレッドと同時プログラミングのコアコンセプトと実用的な手法の深い理解に導かれ、並行プログラミングの達人になるのに役立ちます。

この記事を読むことで、スレッドを作成および管理する方法、同時プログラミングにおける同期と相互除外メカニズムを理解する方法、および一般的な同時プログラミングの落とし穴を回避する方法を学びます。あなたが初心者であろうと経験豊富な開発者であろうと、あなたはそれから利益を得ることができます。

基本的な知識のレビュー

Cマルチスレッドと同時プログラミングに飛び込む前に、最初にいくつかの基本を確認しましょう。 C 11標準では、 <thread></thread>ライブラリを導入し、Cのスレッドの作成と管理をより簡単で直感的に管理します。さらに、 <mutex></mutex> 、 <condition_variable></condition_variable> 、 <atomic></atomic>などのライブラリは、スレッド間の同期と通信を処理するために必要なツールを提供します。

これらの基本的な概念を理解することは、マルチスレッドプログラミングをマスターするために重要です。たとえば、スレッドはオペレーティングシステムのスケジューリングの最小単位であり、ミューテックスは共有リソースを保護し、データ競争を防ぐために使用されます。

コアコンセプトまたは関数分析

スレッドの作成と管理

Cでは、スレッドの作成は非常にシンプルで、 std::threadクラスを使用してください。簡単な例を次に示します。

 #include <iostream>
#include <thread>

void thread_function（）{
    std :: cout << "Hello from thread！" << std :: endl;
}

int main（）{
    std :: thread t（thread_function）;
    T.Join（）;
    0を返します。
}

この例は、スレッドを作成し、それが完了するのを待つ方法を示しています。 join()メソッドは、子スレッドが実行を完了するまでメインスレッドをブロックします。

同期と相互除外

マルチスレッドプログラミングでは、データ競争を回避するための鍵となります。 std::mutex and std::lock_guard一般的に使用されるツールです。ここにミューテックスを使用して共有リソースを保護する例があります。

 #include <iostream>
#include <thread>
#include <Mutex>

std :: mutex mtx;
int shared_data = 0;

void increment（）{
    for（int i = 0; i <100000; i）{
        std :: lock_guard <std :: mutex> lock（mtx）;
          shared_data;
    }
}

int main（）{
    std :: thread t1（increment）;
    std :: thread t2（increment）;
    t1.join（）;
    t2.join（）;
    std :: cout << "shared_dataの最終値：" << shared_data << std :: endl;
    0を返します。
}

この例では、 std::lock_guard 、 shared_dataにアクセスするときにMutexが適切にロックされてロックされていることを確認し、データ競合を回避します。

条件付き変数

条件変数は、スレッド間の通信に使用されるもう1つの重要な同期メカニズムです。条件付き変数を使用する例は次のとおりです。

 #include <iostream>
#include <thread>
#include <Mutex>
#include <condition_variable>

std :: mutex mtx;
std :: condition_variable cv;
bool ready = false;

void print_id（int id）{
    std :: unique_lock <std :: mutex> lck（mtx）;
    while（！ready）cv.wait（lck）;
    std :: cout << "thread" << id << std :: endl;
}

void go（）{
    std :: unique_lock <std :: mutex> lck（mtx）;
    Ready = true;
    cv.notify_all（）;
}

int main（）{
    std ::スレッドスレッド[10];
    for（int i = 0; i <10; i）{
        スレッド[i] = std :: thread（print_id、i）;
    }
    std :: cout << "10個のスレッドレースの準備ができています..." << std :: endl;
    行く（）;
    for（auto＆th：threads）th.join（）;
    0を返します。
}

この例では、条件変数cvを使用して、すべての待機スレッドを通知して実行を開始します。

使用の例

基本的な使用法

スレッドの作成と管理は、マルチスレッドプログラミングの基礎です。スレッドプールを使用してタスクを並行して処理する方法を示すより複雑な例を以下に示します。

 #include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <Mutex>
#include <condition_variable>
#include <Functional>

クラススレッドプール{
公共：
    threadpool（size_t threads）：stop（false）{
        for（size_t i = 0; i <threads; i）{
            workers.emplace_back（[this] {
                while（true）{
                    std :: function <void（）> task;
                    {
                        std :: unique_lock <std :: mutex> lock（queue_mutex）;
                        condition.wait（lock、[this] {return stop ||！tasks.empty（）;}）;
                        if（stop && tasks.empty（））return;
                        task = std :: move（tasks.front（））;
                        tasks.pop（）;
                    }
                    タスク（）;
                }
            }）;
        }
    }

    テンプレート<クラスF、クラス... args>
    auto enqueue（f && f、args && ... args） 
         - > std :: future <typename std :: result_of <f（args ...）> :: type>
    {
        return_type = typename std :: result_of <f（args ...）> :: typeを使用する

        auto task = std :: make_shared <std :: packaged_task <return_type（）>>（
            std :: bind（std :: forward <f>（f）、std :: forward <args>（args）...）
        ）;

        std :: future <Retrent_type> res = task-> get_future（）;
        {
            std :: unique_lock <std :: mutex> lock（queue_mutex）;
            if（停止）std :: runtime_error（ "enqueue on stopped threadpool"）;
            tasks.emplace（[task]（）{（*task）（）;}）;
        }
        condition.notify_one（）;
        RESを返します。
    }

    〜ThreadPool（）{
        {
            std :: unique_lock <std :: mutex> lock（queue_mutex）;
            stop = true;
        }
        condition.notify_all（）;
        for（std :: thread＆worker：workers）worker.join（）;
    }

プライベート：
    std :: vector <std :: thread> workers;
    std :: queue <std :: function <void（）>> tasks;

    std :: mutex queue_mutex;
    std :: condition_variable条件;
    ブールストップ;
};

int main（）{
    ThreadPoolプール（4）;
    std :: vector <std :: future <int >> results;

    for（int i = 0; i <8; i）{
        results.emplace_back（
            pool.enqueue（[i] {
                i * iを返します。
            }）
        ）;
    }

    for（auto && result：results）{
        std :: cout << result.get（）<< &#39;&#39;;
    }
    std :: cout << std :: endl;

    0を返します。
}

この例は、スレッドプールを使用してタスクを並行して処理する方法を示しており、プログラムの並行性と効率を改善します。

高度な使用

実際のアプリケーションでは、より複雑な同時プログラミングシナリオが発生する可能性があります。たとえば、 std::asyncとstd::futureを使用して非同期プログラミングを実装します。

 #include <iostream>
#include <future>
#include <Chrono>

int main（）{
    Auto Future = std :: async（std :: launch :: async、[] {
        std :: this_thread :: sleep_for（std :: chrono ::秒（2））;
        返品42;
    }）;

    std :: cout << "結果を待つ..." << std :: endl;
    int result = future.get（）;
    std :: cout << "result：" << result << std :: endl;

    0を返します。
}

この例では、 std::async非同期タスクを開始するために使用され、 std::futureタスクの結果を取得するために使用されます。

一般的なエラーとデバッグのヒント

マルチスレッドプログラミングの一般的なエラーには、データレース、デッドロック、リソースリークが含まれます。デバッグのヒントは次のとおりです。

• std::lock_guardとstd::unique_lockを使用して、ミューテックスの正しい使用を確保し、デッドロックを避けます。
• std::atomicを使用して共有変数を処理し、データ競合を回避します。
• ValgrindやOrdressSanitizerなどのデバッグツールを使用して、メモリリークとデータ競合を検出します。

パフォーマンスの最適化とベストプラクティス

実際のアプリケーションでは、マルチスレッドプログラムのパフォーマンスを最適化することが重要です。いくつかの最適化のヒントとベストプラクティスは次のとおりです。

• 過度のスレッドの作成と破壊を避け、スレッドプールを使用してスレッドを管理します。
• std::atomicを使用して、共有変数のアクセス効率を向上させます。
• ロックを合理的に使用して、ロックの粒度を減らし、ロック競争を避けます。

たとえば、 std::atomicを使用して共有変数へのアクセスを最適化する例を次に示します。

 #include <iostream>
#include <thread>
#include <Atomic>

std :: atomic <int> shared_data（0）;

void increment（）{
    for（int i = 0; i <100000; i）{
          shared_data;
    }
}

int main（）{
    std :: thread t1（increment）;
    std :: thread t2（increment）;
    t1.join（）;
    t2.join（）;
    std :: cout << "shared_dataの最終値：" << shared_data << std :: endl;
    0を返します。
}

この例では、 std::atomicを使用して共有変数のアトミック動作を確保すると、プログラムのパフォーマンスとセキュリティが向上します。

要するに、Cマルチスレッドと同時プログラミングは複雑ですが非常に有用な技術です。この記事の研究を通じて、スレッドの作成と管理、同期と相互除外、パフォーマンスの最適化など、コアの概念とテクニックを習得する必要があります。この知識が、実際のプロジェクトでマルチスレッドプログラミングをより適切に適用し、プログラムのパフォーマンスと応答性を向上させるのに役立つことを願っています。

以上がCマルチスレッドと並行性：並列プログラミングのマスタリングの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。