C#で学ぶスレッド管理と同期方法：初心者ガイド

C#のスレッド管理と同期方法を理解し、マルチスレッドアプリケーションの効率的な作成を目指します。本記事では、スレッドの基本概念から実践的な同期手法までを丁寧に解説します。初心者にも分かりやすく、具体的なコード例とともに説明することで、実際の開発に役立つ知識を提供します。

スレッドの基本概念
スレッドの作成方法
スレッドのライフサイクル管理
スレッドの同期とは
ロック機構の使用方法
Monitorクラスの利用
MutexとSemaphore
スレッドプールの利用
非同期プログラミングの基礎
スレッド関連の応用例
演習問題
まとめ

スレッドの基本概念

スレッドは、プログラムの中で独立して実行される最小の処理単位です。複数のスレッドを使用することで、プログラムが並列にタスクを処理でき、効率が向上します。特に、ユーザーインターフェイスが応答性を保ちながらバックグラウンドでタスクを実行する場合や、マルチコアプロセッサを活用する場合に有効です。C#では、System.Threading名前空間を使用してスレッドを操作します。以下に基本的なスレッドの概念と用語を紹介します。

プロセスとスレッド

プロセスは実行中のプログラムのインスタンスで、独自のメモリ空間を持ちます。スレッドはプロセス内で動作し、プロセス内のリソースを共有します。一つのプロセスに複数のスレッドが存在することができます。

マルチスレッドの利点

効率的なリソース利用: マルチスレッドは、CPUのマルチコア構成を最大限に活用します。
応答性の向上: ユーザーインターフェイスをブロックせずにバックグラウンドでタスクを実行できます。
スケーラビリティ: 大規模なデータ処理や並列計算を効率的に行えます。

基本用語

スレッド: プロセス内で独立して実行される最小の処理単位。
コンテキストスイッチ: スレッド間でCPUの実行コンテキストを切り替える操作。
同期: 複数のスレッド間でリソースを安全に共有するための技術。

スレッドの作成方法

C#では、System.Threading名前空間を使用してスレッドを作成し操作することができます。基本的なスレッドの作成方法を以下に紹介します。

Threadクラスを使用したスレッドの作成

Threadクラスを使用して、新しいスレッドを作成し、実行することができます。以下は基本的な例です。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 新しいスレッドを作成
        Thread myThread = new Thread(new ThreadStart(MyThreadMethod));

        // スレッドを開始
        myThread.Start();

        // メインスレッドの作業
        Console.WriteLine("Main thread is running...");
    }

    static void MyThreadMethod()
    {
        // 新しいスレッドで実行するメソッド
        Console.WriteLine("New thread is running...");
    }
}

ラムダ式を使用したスレッドの作成

ラムダ式を使用して、スレッドのメソッドを簡潔に記述することもできます。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // ラムダ式を使用して新しいスレッドを作成
        Thread myThread = new Thread(() => 
        {
            Console.WriteLine("New thread is running with lambda...");
        });

        // スレッドを開始
        myThread.Start();

        // メインスレッドの作業
        Console.WriteLine("Main thread is running...");
    }
}

パラメータ付きスレッドの作成

ParameterizedThreadStartデリゲートを使用して、スレッドにパラメータを渡すことができます。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // パラメータ付きのスレッドを作成
        Thread myThread = new Thread(new ParameterizedThreadStart(MyThreadMethod));

        // スレッドを開始し、パラメータを渡す
        myThread.Start("Hello from new thread!");

        // メインスレッドの作業
        Console.WriteLine("Main thread is running...");
    }

    static void MyThreadMethod(object obj)
    {
        // 新しいスレッドで実行するメソッド
        string message = (string)obj;
        Console.WriteLine(message);
    }
}

これらの方法を使用することで、C#で効率的にスレッドを作成し、マルチスレッドプログラミングの基礎を築くことができます。

スレッドのライフサイクル管理

スレッドのライフサイクル管理は、スレッドの開始、実行中、停止、終了の各ステージを適切に制御することです。これにより、プログラムのパフォーマンスと安定性を確保します。C#ではThreadクラスを使用してスレッドのライフサイクルを管理します。

スレッドの開始

スレッドを作成した後、Startメソッドを呼び出してスレッドを開始します。

Thread myThread = new Thread(new ThreadStart(MyThreadMethod));
myThread.Start();

スレッドの一時停止と再開

スレッドを一時的に停止するには、Thread.Sleepメソッドを使用します。特定の時間だけスレッドを停止する場合に有効です。

Thread.Sleep(1000); // スレッドを1秒間停止

スレッドの終了

スレッドを終了させるには、スレッド内のメソッドを自然に終了させることが推奨されます。Thread.Abortメソッドを使用して強制終了することもできますが、これは推奨されません。

// 推奨される方法: スレッドメソッド内での終了処理
void MyThreadMethod()
{
    // 何らかの条件でループを終了
    while (condition)
    {
        // 処理
    }
}

// 推奨されない方法: Thread.Abortを使用して強制終了
myThread.Abort();

スレッドのステータス確認

スレッドの状態を確認するために、Thread.ThreadStateプロパティを使用します。このプロパティは、スレッドの現在の状態を示します。

if (myThread.ThreadState == ThreadState.Running)
{
    Console.WriteLine("スレッドは実行中です。");
}
else if (myThread.ThreadState == ThreadState.Stopped)
{
    Console.WriteLine("スレッドは停止しました。");
}

スレッドの優先度設定

スレッドの優先度を設定することで、スケジューリングの順序を制御できます。Thread.Priorityプロパティを使用して、スレッドの優先度を設定します。

myThread.Priority = ThreadPriority.Highest;

スレッドのライフサイクル管理を理解することで、効率的なマルチスレッドプログラミングが可能となり、アプリケーションのパフォーマンスと信頼性が向上します。

スレッドの同期とは

スレッドの同期は、複数のスレッドが同じリソースに同時にアクセスする際の競合状態を防ぐための手法です。適切な同期を行うことで、データの整合性を保ち、安全で効率的なマルチスレッドプログラミングを実現します。

なぜ同期が必要か

マルチスレッドプログラミングでは、複数のスレッドが同じ変数やオブジェクトにアクセスすることがよくあります。このとき、適切な同期を行わないと以下のような問題が発生する可能性があります。

データ競合: 複数のスレッドが同時にデータを書き換えることで、データの整合性が崩れる。
デッドロック: 複数のスレッドが互いにリソースを待ち続けることで、システムが停止する。
レースコンディション: スレッドの実行順序によって異なる結果が得られる。

同期の基本概念

同期を実現するためには、以下の基本概念を理解することが重要です。

クリティカルセクション: 同時に一つのスレッドしか実行できないコードの部分。
ロック: スレッドがクリティカルセクションに入る際に使用するメカニズム。

スレッド間の同期の方法

C#では、以下の主要な方法でスレッドの同期を行います。

lockステートメント

最も一般的な同期方法はlockステートメントを使用することです。lockステートメントは、指定されたオブジェクトに対してロックを取得し、クリティカルセクションを保護します。

class Program
{
    private static readonly object lockObject = new object();

    static void Main()
    {
        Thread thread1 = new Thread(Method);
        Thread thread2 = new Thread(Method);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void Method()
    {
        lock (lockObject)
        {
            // クリティカルセクション
            Console.WriteLine("Thread {0} is in the critical section.", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000);
        }
    }
}

Monitorクラス

Monitorクラスは、lockステートメントと同様に動作しますが、より高度な機能を提供します。Enterメソッドでロックを取得し、Exitメソッドでロックを解放します。

class Program
{
    private static readonly object lockObject = new object();

    static void Main()
    {
        Thread thread1 = new Thread(Method);
        Thread thread2 = new Thread(Method);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void Method()
    {
        Monitor.Enter(lockObject);
        try
        {
            // クリティカルセクション
            Console.WriteLine("Thread {0} is in the critical section.", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000);
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }
}

これらの同期手法を使用することで、スレッド間の競合状態を防ぎ、安全かつ効率的なマルチスレッドプログラミングを実現することができます。

ロック機構の使用方法

ロック機構を使用することで、複数のスレッドが同時に同じリソースにアクセスすることを防ぎます。C#では、lockステートメントを使用して簡単にロックを実装することができます。

lockステートメントの基本

lockステートメントは、特定のオブジェクトに対してロックを取得し、クリティカルセクションのコードが他のスレッドから保護されるようにします。

class Program
{
    private static readonly object lockObject = new object();
    private static int sharedResource = 0;

    static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final value of sharedResource: " + sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (lockObject)
            {
                // クリティカルセクション
                sharedResource++;
            }
        }
    }
}

lockステートメントの使用上の注意

ロックオブジェクトの選定: ロックには専用のオブジェクトを使用し、公開されているフィールドやプロパティは避けます。
デッドロックの防止: ロックの取得順序に注意し、複数のロックを必要とする場合は一貫した順序で取得するようにします。

ネストされたlockステートメント

複数のロックを使用する場合、一貫した順序でロックを取得することが重要です。

class Program
{
    private static readonly object lockObject1 = new object();
    private static readonly object lockObject2 = new object();

    static void Main()
    {
        Thread thread1 = new Thread(Method1);
        Thread thread2 = new Thread(Method2);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void Method1()
    {
        lock (lockObject1)
        {
            lock (lockObject2)
            {
                // クリティカルセクション
                Console.WriteLine("Method1 is in the critical section.");
            }
        }
    }

    static void Method2()
    {
        lock (lockObject1)
        {
            lock (lockObject2)
            {
                // クリティカルセクション
                Console.WriteLine("Method2 is in the critical section.");
            }
        }
    }
}

ロックのパフォーマンス

ロックを多用するとパフォーマンスに影響を与えることがあります。必要最小限のロックを使用し、可能であればロックの範囲を狭くすることで、パフォーマンスの低下を防ぎます。

これらの基本的なロック機構を理解し、適切に使用することで、安全かつ効率的なマルチスレッドプログラミングが可能になります。

Monitorクラスの利用

Monitorクラスは、より高度な同期手法を提供し、ロックの取得や解放を明示的に制御することができます。Monitorクラスは、lockステートメントと同様に動作しますが、タイムアウトや待機などの追加機能を提供します。

Monitorクラスの基本

Monitorクラスを使用するには、Enterメソッドでロックを取得し、Exitメソッドでロックを解放します。以下は基本的な使用例です。

class Program
{
    private static readonly object lockObject = new object();
    private static int sharedResource = 0;

    static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final value of sharedResource: " + sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            Monitor.Enter(lockObject);
            try
            {
                // クリティカルセクション
                sharedResource++;
            }
            finally
            {
                Monitor.Exit(lockObject);
            }
        }
    }
}

Monitor.TryEnter

TryEnterメソッドを使用すると、指定したタイムアウト期間内にロックを取得できるかどうかを確認できます。これにより、デッドロックを防止し、スレッドが長時間待機するのを避けることができます。

class Program
{
    private static readonly object lockObject = new object();
    private static int sharedResource = 0;

    static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final value of sharedResource: " + sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            if (Monitor.TryEnter(lockObject, TimeSpan.FromMilliseconds(500)))
            {
                try
                {
                    // クリティカルセクション
                    sharedResource++;
                }
                finally
                {
                    Monitor.Exit(lockObject);
                }
            }
            else
            {
                Console.WriteLine("Thread {0} could not acquire the lock.", Thread.CurrentThread.ManagedThreadId);
            }
        }
    }
}

WaitとPulse

Monitor.WaitとMonitor.Pulseメソッドを使用すると、スレッドが特定の条件が満たされるまで待機し、条件が満たされたときに他のスレッドを通知することができます。これにより、複雑な同期シナリオを実現できます。

class Program
{
    private static readonly object lockObject = new object();
    private static bool condition = false;

    static void Main()
    {
        Thread thread1 = new Thread(WaitForCondition);
        Thread thread2 = new Thread(SignalCondition);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void WaitForCondition()
    {
        Monitor.Enter(lockObject);
        try
        {
            while (!condition)
            {
                Monitor.Wait(lockObject);
            }
            Console.WriteLine("Condition met, proceeding with work.");
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }

    static void SignalCondition()
    {
        Monitor.Enter(lockObject);
        try
        {
            condition = true;
            Monitor.Pulse(lockObject);
            Console.WriteLine("Condition signaled.");
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }
}

Monitorクラスを利用することで、ロックの取得と解放の制御をより詳細に行うことができ、複雑な同期問題を解決するのに役立ちます。

MutexとSemaphore

MutexとSemaphoreは、複数のスレッド間でリソースのアクセスを制御するための高度な同期手法です。これらは、特定の条件下で使用することで、より効率的なスレッド同期を実現できます。

Mutexの利用

Mutex（ミューテックス）は、単一のスレッドがリソースを独占的に使用するためのロックを提供します。複数のプロセス間でも共有できるため、異なるプロセス間での同期にも使用できます。

using System;
using System.Threading;

class Program
{
    static Mutex mutex = new Mutex();

    static void Main()
    {
        Thread thread1 = new Thread(Method);
        Thread thread2 = new Thread(Method);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }

    static void Method()
    {
        Console.WriteLine("Thread {0} is waiting for the mutex.", Thread.CurrentThread.ManagedThreadId);
        mutex.WaitOne(); // ミューテックスを取得
        try
        {
            Console.WriteLine("Thread {0} has entered the critical section.", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000); // クリティカルセクション内での処理
        }
        finally
        {
            Console.WriteLine("Thread {0} is releasing the mutex.", Thread.CurrentThread.ManagedThreadId);
            mutex.ReleaseMutex(); // ミューテックスを解放
        }
    }
}

Semaphoreの利用

Semaphore（セマフォ）は、一定数のスレッドが同時にリソースにアクセスできるようにするためのカウンターロックです。リソースの数を指定でき、複数のスレッドが同時にアクセスできる場合に適しています。

using System;
using System.Threading;

class Program
{
    static Semaphore semaphore = new Semaphore(2, 2); // 同時に2つのスレッドを許可

    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Thread thread = new Thread(Method);
            thread.Start(i + 1);
        }
    }

    static void Method(object id)
    {
        Console.WriteLine("Thread {0} is waiting for the semaphore.", id);
        semaphore.WaitOne(); // セマフォを取得
        try
        {
            Console.WriteLine("Thread {0} has entered the critical section.", id);
            Thread.Sleep(1000); // クリティカルセクション内での処理
        }
        finally
        {
            Console.WriteLine("Thread {0} is releasing the semaphore.", id);
            semaphore.Release(); // セマフォを解放
        }
    }
}

MutexとSemaphoreの違い

Mutex: 一度に一つのスレッドしかリソースにアクセスできない。プロセス間での同期も可能。
Semaphore: 一度に複数のスレッドがリソースにアクセスできる。指定した数だけのスレッドが同時にアクセス可能。

これらの同期手法を理解し適切に使用することで、複雑なマルチスレッド環境でのリソース管理が容易になります。

スレッドプールの利用

スレッドプールは、スレッドの再利用を効率的に行うための仕組みです。これにより、新しいスレッドを生成するオーバーヘッドを削減し、アプリケーションのパフォーマンスを向上させることができます。C#では、ThreadPoolクラスを使用してスレッドプールを簡単に利用できます。

スレッドプールの基本

ThreadPoolクラスは、複数のスレッドを効率的に管理し、必要に応じてタスクを割り当てます。スレッドプールは、特定の数のスレッドを維持し、新しいタスクが追加されると、アイドル状態のスレッドがそのタスクを処理します。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            ThreadPool.QueueUserWorkItem(new WaitCallback(TaskMethod), taskNumber);
        }

        Console.WriteLine("Main thread does some work, then sleeps.");
        Thread.Sleep(1000); // メインスレッドの作業
    }

    static void TaskMethod(object state)
    {
        int taskNumber = (int)state;
        Console.WriteLine("Task {0} is running on thread {1}.", taskNumber, Thread.CurrentThread.ManagedThreadId);
    }
}

スレッドプールの利点

効率性: スレッドの生成と破棄のオーバーヘッドを削減します。
スケーラビリティ: 多くのタスクを効率的に処理でき、スレッドプールのサイズを自動的に調整します。
簡便性: ThreadPoolクラスを使用することで、スレッド管理の手間が省けます。

スレッドプールの設定

スレッドプールの最小スレッド数や最大スレッド数を設定することができます。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // スレッドプールの最小スレッド数を設定
        ThreadPool.SetMinThreads(2, 2);

        // スレッドプールの最大スレッド数を設定
        ThreadPool.SetMaxThreads(4, 4);

        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            ThreadPool.QueueUserWorkItem(new WaitCallback(TaskMethod), taskNumber);
        }

        Console.WriteLine("Main thread does some work, then sleeps.");
        Thread.Sleep(1000); // メインスレッドの作業
    }

    static void TaskMethod(object state)
    {
        int taskNumber = (int)state;
        Console.WriteLine("Task {0} is running on thread {1}.", taskNumber, Thread.CurrentThread.ManagedThreadId);
    }
}

Taskクラスとの統合

Taskクラスを使用することで、スレッドプールのタスク管理をさらに簡素化できます。Taskクラスは、非同期操作を扱うための高レベルの抽象化を提供します。

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task[] tasks = new Task[5];

        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            tasks[i] = Task.Run(() => TaskMethod(taskNumber));
        }

        Task.WaitAll(tasks); // すべてのタスクが完了するまで待機

        Console.WriteLine("All tasks are complete.");
    }

    static void TaskMethod(int taskNumber)
    {
        Console.WriteLine("Task {0} is running on thread {1}.", taskNumber, Thread.CurrentThread.ManagedThreadId);
    }
}

スレッドプールを利用することで、効率的なスレッド管理が可能になり、アプリケーションのパフォーマンスを大幅に向上させることができます。

非同期プログラミングの基礎

非同期プログラミングは、長時間実行される操作を非同期に実行し、アプリケーションの応答性を向上させるための手法です。C#では、asyncおよびawaitキーワードを使用して非同期メソッドを簡単に作成できます。

非同期メソッドの作成

非同期メソッドは、asyncキーワードを使用して定義します。awaitキーワードを使用して非同期操作が完了するのを待機します。以下は基本的な例です。

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string url = "https://www.example.com";
        string result = await FetchDataAsync(url);
        Console.WriteLine(result);
    }

    static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            // 非同期でデータを取得
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            return responseBody;
        }
    }
}

asyncおよびawaitの基本概念

async: メソッドを非同期として定義し、awaitキーワードを使用できるようにします。
await: 非同期操作が完了するまで待機し、結果を取得します。

非同期メソッドのエラーハンドリング

非同期メソッド内で例外が発生した場合、通常のtry-catchブロックを使用して例外を処理できます。

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        try
        {
            string url = "https://www.example.com";
            string result = await FetchDataAsync(url);
            Console.WriteLine(result);
        }
        catch (Exception ex)
        {
            Console.WriteLine("An error occurred: " + ex.Message);
        }
    }

    static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            return responseBody;
        }
    }
}

非同期メソッドのキャンセル

CancellationTokenを使用して、非同期操作をキャンセルできます。

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        CancellationTokenSource cts = new CancellationTokenSource();

        Task task = FetchDataAsync("https://www.example.com", cts.Token);

        // キャンセルを発行する
        cts.Cancel();

        try
        {
            await task;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Operation was canceled.");
        }
    }

    static async Task FetchDataAsync(string url, CancellationToken token)
    {
        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url, token);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}

非同期プログラミングの利点

応答性の向上: ユーザーインターフェイスがブロックされず、アプリケーションの応答性が向上します。
効率的なリソース利用: スレッドが待機状態になるのを避け、効率的にリソースを利用します。
スケーラビリティ: 多数の非同期タスクを効率的に管理できます。

非同期プログラミングの基礎を理解し、asyncおよびawaitキーワードを適切に使用することで、C#アプリケーションのパフォーマンスとユーザーエクスペリエンスを大幅に向上させることができます。

スレッド関連の応用例

スレッド管理と同期の基本を理解したら、実際のアプリケーションでどのようにこれらの技術を応用できるかを見ていきましょう。以下に、スレッド関連の応用例をいくつか紹介します。

Webサーバーのシミュレーション

スレッドを使用して、複数のクライアントリクエストを同時に処理する簡単なWebサーバーをシミュレーションします。

using System;
using System.Net;
using System.Threading;

class WebServer
{
    private static readonly object lockObject = new object();
    private static int requestCount = 0;

    public static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Thread thread = new Thread(ProcessRequest);
            thread.Start();
        }
    }

    static void ProcessRequest()
    {
        lock (lockObject)
        {
            requestCount++;
            Console.WriteLine("Processing request {0} on thread {1}", requestCount, Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000); // リクエスト処理のシミュレーション
        }
    }
}

並列計算の実行

大量のデータを並列に処理して、計算時間を短縮する方法です。例えば、配列内の全ての要素に対して並列に処理を行います。

using System;
using System.Threading.Tasks;

class ParallelComputation
{
    public static void Main()
    {
        int[] numbers = new int[1000];
        for (int i = 0; i < numbers.Length; i++)
        {
            numbers[i] = i;
        }

        Parallel.For(0, numbers.Length, i =>
        {
            numbers[i] = numbers[i] * numbers[i];
            Console.WriteLine("Element {0} processed on thread {1}", i, Thread.CurrentThread.ManagedThreadId);
        });

        Console.WriteLine("All elements processed.");
    }
}

リアルタイムデータ処理

センサーからのデータをリアルタイムで処理するアプリケーションでは、スレッドを使用してデータ収集と処理を同時に行います。

using System;
using System.Threading;

class RealTimeDataProcessing
{
    static void Main()
    {
        Thread dataCollectionThread = new Thread(CollectData);
        Thread dataProcessingThread = new Thread(ProcessData);

        dataCollectionThread.Start();
        dataProcessingThread.Start();

        dataCollectionThread.Join();
        dataProcessingThread.Join();
    }

    static void CollectData()
    {
        while (true)
        {
            // データ収集のシミュレーション
            Console.WriteLine("Collecting data on thread {0}", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(500); // データ収集の間隔
        }
    }

    static void ProcessData()
    {
        while (true)
        {
            // データ処理のシミュレーション
            Console.WriteLine("Processing data on thread {0}", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000); // データ処理の間隔
        }
    }
}

GUIアプリケーションの応答性向上

長時間実行される操作をバックグラウンドで実行し、UIスレッドがブロックされないようにすることで、アプリケーションの応答性を向上させます。

using System;
using System.Threading.Tasks;
using System.Windows.Forms;

class ResponsiveUI : Form
{
    private Button button;
    private Label label;

    public ResponsiveUI()
    {
        button = new Button { Text = "Start Task", Dock = DockStyle.Top };
        label = new Label { Text = "Task not started", Dock = DockStyle.Top };
        button.Click += async (sender, e) => await StartTaskAsync();

        Controls.Add(label);
        Controls.Add(button);
    }

    private async Task StartTaskAsync()
    {
        label.Text = "Task started...";
        await Task.Run(() =>
        {
            // 長時間実行される操作
            Thread.Sleep(5000);
        });
        label.Text = "Task completed.";
    }

    static void Main()
    {
        Application.Run(new ResponsiveUI());
    }
}

これらの応用例を通じて、スレッド管理と同期の実践的な使用方法を理解し、実際のアプリケーション開発に役立てることができます。

演習問題

学習した内容を確認するために、以下の演習問題に取り組んでみましょう。各問題は、スレッド管理と同期に関する重要な概念と技術を理解するために設計されています。

演習問題 1: 基本的なスレッドの作成

以下のコードを完成させ、3つのスレッドを作成して、それぞれのスレッドがコンソールに「Hello from thread [Thread ID]」と表示するプログラムを作成してください。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 3; i++)
        {
            // スレッドを作成して開始
            Thread thread = new Thread(new ThreadStart(() =>
            {
                // スレッドIDを表示
                Console.WriteLine("Hello from thread " + Thread.CurrentThread.ManagedThreadId);
            }));
            thread.Start();
        }
    }
}

演習問題 2: スレッドの同期

以下のコードを修正し、スレッド間のデータ競合を防止してください。sharedResourceが予期しない値を持たないようにする必要があります。

using System;
using System.Threading;

class Program
{
    private static int sharedResource = 0;
    private static readonly object lockObject = new object();

    static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final value of sharedResource: " + sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (lockObject)
            {
                sharedResource++;
            }
        }
    }
}

演習問題 3: 非同期プログラミング

次のコードを完成させ、Webページの内容を非同期で取得し、取得結果をコンソールに表示するプログラムを作成してください。

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string url = "https://www.example.com";
        string result = await FetchDataAsync(url);
        Console.WriteLine(result);
    }

    static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            // 非同期でデータを取得し、結果を返す
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            return responseBody;
        }
    }
}

演習問題 4: Monitorクラスの使用

以下のコードを修正して、Monitorクラスを使用してスレッド間の競合を防止してください。

using System;
using System.Threading;

class Program
{
    private static readonly object lockObject = new object();
    private static int sharedResource = 0;

    static void Main()
    {
        Thread thread1 = new Thread(IncrementResource);
        Thread thread2 = new Thread(IncrementResource);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final value of sharedResource: " + sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            Monitor.Enter(lockObject);
            try
            {
                sharedResource++;
            }
            finally
            {
                Monitor.Exit(lockObject);
            }
        }
    }
}

演習問題 5: スレッドプールの利用

スレッドプールを使用して、以下のコードを修正し、複数のタスクを並行して実行するプログラムを作成してください。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            int taskNumber = i;
            ThreadPool.QueueUserWorkItem(new WaitCallback(TaskMethod), taskNumber);
        }

        Console.WriteLine("Main thread does some work, then sleeps.");
        Thread.Sleep(1000);
    }

    static void TaskMethod(object state)
    {
        int taskNumber = (int)state;
        Console.WriteLine("Task {0} is running on thread {1}.", taskNumber, Thread.CurrentThread.ManagedThreadId);
    }
}

これらの演習問題を通じて、スレッド管理と同期の実践的なスキルをさらに深めることができます。各問題に取り組み、解答を実装することで、実際のアプリケーション開発に役立つ知識を確実に習得してください。

まとめ

C#におけるスレッド管理と同期方法の基本を学びました。スレッドの基本概念から始まり、スレッドの作成方法、ライフサイクル管理、同期の重要性と具体的な方法について理解を深めました。ロック機構の使用やMonitorクラス、MutexとSemaphore、スレッドプールの利用など、多岐にわたる同期手法を学ぶことで、安全かつ効率的なマルチスレッドプログラミングが可能になります。さらに、非同期プログラミングの基礎と応用例、演習問題を通じて実践的なスキルも身につけました。これらの知識を活用して、より高度でパフォーマンスの高いアプリケーションを開発してください。