web-dev-qa-db-ja.com

C＃プロデューサー/コンシューマー

最近、プロデューサー/コンシューマーパターンのc＃実装に遭遇しました。とてもシンプルで、（少なくとも私にとっては）とてもエレガントです。

2006年頃に考案されたようですので、この実装は
- 安全
-まだ適用可能

コードは下にあります（元のコードは http://bytes.com/topic/net/answers/575276-producer-consumer#post2251375 で参照されていました）

using System;  
using System.Collections;  
using System.Threading;

public class Test
{  
    static ProducerConsumer queue;

    static void Main()
    {
        queue = new ProducerConsumer();
        new Thread(new ThreadStart(ConsumerJob)).Start();

        Random rng = new Random(0);
        for (int i=0; i < 10; i++)
        {
            Console.WriteLine ("Producing {0}", i);
            queue.Produce(i);
            Thread.Sleep(rng.Next(1000));
        }
    }

    static void ConsumerJob()
    {
        // Make sure we get a different random seed from the
        // first thread
        Random rng = new Random(1);
        // We happen to know we've only got 10 
        // items to receive
        for (int i=0; i < 10; i++)
        {
            object o = queue.Consume();
            Console.WriteLine ("\t\t\t\tConsuming {0}", o);
            Thread.Sleep(rng.Next(1000));
        }
    }
}

public class ProducerConsumer
{
    readonly object listLock = new object();
    Queue queue = new Queue();

    public void Produce(object o)
    {
        lock (listLock)
        {
            queue.Enqueue(o);

            // We always need to Pulse, even if the queue wasn't
            // empty before. Otherwise, if we add several items
            // in quick succession, we may only Pulse once, waking
            // a single thread up, even if there are multiple threads
            // waiting for items.            
            Monitor.Pulse(listLock);
        }
    }

    public object Consume()
    {
        lock (listLock)
        {
            // If the queue is empty, wait for an item to be added
            // Note that this is a while loop, as we may be pulsed
            // but not wake up before another thread has come in and
            // consumed the newly added object. In that case, we'll
            // have to wait for another Pulse.
            while (queue.Count==0)
            {
                // This releases listLock, only reacquiring it
                // after being woken up by a call to Pulse
                Monitor.Wait(listLock);
            }
            return queue.Dequeue();
        }
    }
}
c#design-patternsmonitorproducer-consumer
26
lboregard

コードはそれより古い-.NET 2.0が出る前に私はそれを書いた。プロデューサー/コンシューマーキューのconceptはwayより古いですが:)

はい、そのコードは私が知っている限り安全ですが、いくつかの欠点があります。

  • それは一般的ではありません。最新のバージョンは確かに一般的です。
  • キューを停止する方法はありません。キューを停止する簡単な方法の1つは（すべてのコンシューマスレッドが終了するように）、キューに入れることができる「作業停止」トークンを用意することです。次に、スレッドと同じ数のトークンを追加します。または、停止することを示す別のフラグがあります。 （これにより、キュー内の現在の作業をすべて完了する前に、他のスレッドを停止できます。）
  • ジョブが非常に小さい場合、一度に1つのジョブを消費することは、最も効率的な方法ではない可能性があります。

正直に言うと、コードの背後にあるアイデアは、コード自体よりも重要です。

33
Jon Skeet

次のコードスニペットのようなことができます。これは汎用的であり、null（または使用するフラグ）をエンキューしてワーカースレッドに終了するように指示するメソッドがあります。

コードはここから取得されます： http://www.albahari.com/threading/part4.aspx#_Wait_and_Pulse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{

    public class TaskQueue<T> : IDisposable where T : class
    {
        object locker = new object();
        Thread[] workers;
        Queue<T> taskQ = new Queue<T>();

        public TaskQueue(int workerCount)
        {
            workers = new Thread[workerCount];

            // Create and start a separate thread for each worker
            for (int i = 0; i < workerCount; i++)
                (workers[i] = new Thread(Consume)).Start();
        }

        public void Dispose()
        {
            // Enqueue one null task per worker to make each exit.
            foreach (Thread worker in workers) EnqueueTask(null);
            foreach (Thread worker in workers) worker.Join();
        }

        public void EnqueueTask(T task)
        {
            lock (locker)
            {
                taskQ.Enqueue(task);
                Monitor.PulseAll(locker);
            }
        }

        void Consume()
        {
            while (true)
            {
                T task;
                lock (locker)
                {
                    while (taskQ.Count == 0) Monitor.Wait(locker);
                    task = taskQ.Dequeue();
                }
                if (task == null) return;         // This signals our exit
                Console.Write(task);
                Thread.Sleep(1000);              // Simulate time-consuming task
            }
        }
    }
}
28
dashton

その日、上記のコードと 記事シリーズ からMonitor.Wait/Pulseがどのように機能するか（そして一般的にスレッドについて多くのこと）を学びました。ジョンが言うように、それはそれに多くの価値があり、実際に安全で適切です。

ただし、.NET 4以降は フレームワークにプロデューサー-コンシューマーキューの実装 があります。私はそれを自分で見つけただけですが、この時点までに必要なすべてを実行します。

17
kicsit

警告：コメントを読むと、私の答えが間違っていることがわかるでしょう:)

コード内にdeadlockが存在する可能性があります。

次のケースを想像してください。わかりやすくするために、シングルスレッドのアプローチを使用しましたが、スリープを使用してマルチスレッドに簡単に変換できるはずです。

// We create some actions...
object locker = new object();

Action action1 = () => {
    lock (locker)
    {
        System.Threading.Monitor.Wait(locker);
        Console.WriteLine("This is action1");
    }
};

Action action2 = () => {
    lock (locker)
    {
        System.Threading.Monitor.Wait(locker);
        Console.WriteLine("This is action2");
    }
};

// ... (stuff happens, etc.)

// Imagine both actions were running
// and there's 0 items in the queue

// And now the producer kicks in...
lock (locker)
{
    // This would add a job to the queue

    Console.WriteLine("Pulse now!");
    System.Threading.Monitor.Pulse(locker);
}

// ... (more stuff)
// and the actions finish now!

Console.WriteLine("Consume action!");
action1(); // Oops... they're locked...
action2();

これが意味をなさない場合はお知らせください。

これが確認された場合、質問に対する答えは「いいえ、安全ではありません」です;）これがお役に立てば幸いです。

0
DiogoNeves