تنفيذ قائمة انتظار الحظر الآمن لمؤشر الترابط على .NET

Question

أنا أبحث عن تطبيق لقائمة انتظار الحظر الآمن لمؤشر الترابط لـ .NET.أعني بـ "قائمة انتظار الحظر الآمن لمؤشر الترابط":- الوصول الآمن لمؤشر الترابط إلى قائمة الانتظار حيث يقوم استدعاء أسلوب Dequeue بحظر مؤشر ترابط حتى يضع مؤشر ترابط آخر (Enqueue) بعض القيمة.

بحلول اللحظة التي وجدت فيها هذا:http://www.eggheadcafe.com/articles/20060414.asp(لكنه مخصص لـ .NET 1.1).

هل يمكن لأي شخص التعليق/النقد على صحة هذا التنفيذ.أو أقترح بعض واحد آخر.شكرا لك مقدما.

Answer 1

وماذا عن هذا إنشاء قائمة انتظار عرقلة في NET.

إذا كنت في حاجة إليها ل.NET Framework 1.1 (لم أكن متأكدا من السؤال)، مجرد قطرة في الأدوية واستبدال T مع object.

Answer 2

كمرجع، يقدم .NET 4 System.Collections.Concurrent.BlockingCollection<T> اكتب لمعالجة هذا.بالنسبة لقائمة الانتظار غير المحظورة، يمكنك استخدام System.Collections.Concurrent.ConcurrentQueue<T>.لاحظ أن ConcurrentQueue<T> من المحتمل أن يتم استخدامه كمخزن بيانات أساسي لـ BlockingCollection<T> لاستخدام OP.

Answer 3

HTTP : //msdn.microsoft.com/en-us/library/system.collections.queue.synchronized (VS.71) .aspx اتصال

هل نقطة انطلاق على أي حال، لقد استعملت أبدا قائمة انتظار الحظر. آسف لهذا المنصب لا صلة لذلك.

Answer 4

والمثال مايكروسوفت هي فكرة جيدة ولكن لا يتم تغليف هو داخل الصف. أيضا، فإنه يتطلب أن موضوع المستهلك قيد التشغيل في MTA (بسبب الدعوة WaitAny). هناك بعض الحالات التي قد تحتاج إلى تشغيل في STA (على سبيل المثال، إذا كنت تفعل إمكانية التشغيل المتداخل COM). في هذه الحالات، WaitAny لا يمكن استخدامها.

ولدي حجب بسيطة الطبقة قائمة الانتظار التي يتغلب هذه المسألة هنا: http://element533.blogspot.com/2010/ 01 / أيقافه حجب قائمة انتظار مقابل net.html

Answer 5

نعم، .NET4 يحتوي على مجموعات المتزامنة. راجع للشغل، دليل جميل جدا جدا حول ملحقات المتوازية من فريق PFX - <وأ href = "http://www.microsoft.com/downloads/details.aspx؟FamilyID=86b3d32b-ad26-4bb8-a3ae-c1637026c3ee&displaylang=en" يختلط = "noreferrer نوفولو"> http://www.microsoft.com/downloads/details.aspx؟FamilyID=86b3d32b-ad26-4bb8-a3ae-c1637026c3ee&displaylang=en .

وPFX هو متاح أيضا لصافي 3.5 كجزء من الامتدادات رد الفعل.

Answer 6

لدى Microsoft عينة جميلة جدًا حول هذا:

//Copyright (C) Microsoft Corporation.  All rights reserved.

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

// The thread synchronization events are encapsulated in this 
// class to allow them to easily be passed to the Consumer and 
// Producer classes. 
public class SyncEvents
{
    public SyncEvents()
    {
        // AutoResetEvent is used for the "new item" event because
        // we want this event to reset automatically each time the
        // consumer thread responds to this event.
        _newItemEvent = new AutoResetEvent(false);

        // ManualResetEvent is used for the "exit" event because
        // we want multiple threads to respond when this event is
        // signaled. If we used AutoResetEvent instead, the event
        // object would revert to a non-signaled state with after 
        // a single thread responded, and the other thread would 
        // fail to terminate.
        _exitThreadEvent = new ManualResetEvent(false);

        // The two events are placed in a WaitHandle array as well so
        // that the consumer thread can block on both events using
        // the WaitAny method.
        _eventArray = new WaitHandle[2];
        _eventArray[0] = _newItemEvent;
        _eventArray[1] = _exitThreadEvent;
    }

    // Public properties allow safe access to the events.
    public EventWaitHandle ExitThreadEvent
    {
        get { return _exitThreadEvent; }
    }
    public EventWaitHandle NewItemEvent
    {
        get { return _newItemEvent; }
    }
    public WaitHandle[] EventArray
    {
        get { return _eventArray; }
    }

    private EventWaitHandle _newItemEvent;
    private EventWaitHandle _exitThreadEvent;
    private WaitHandle[] _eventArray;
}

// The Producer class asynchronously (using a worker thread)
// adds items to the queue until there are 20 items.
public class Producer 
{
    public Producer(Queue<int> q, SyncEvents e)
    {
        _queue = q;
        _syncEvents = e;
    }
    public void ThreadRun()
    {
        int count = 0;
        Random r = new Random();
        while (!_syncEvents.ExitThreadEvent.WaitOne(0, false))
        {
            lock (((ICollection)_queue).SyncRoot)
            {
                while (_queue.Count < 20)
                {
                    _queue.Enqueue(r.Next(0, 100));
                    _syncEvents.NewItemEvent.Set();
                    count++;
                }
            }
        }
        Console.WriteLine("Producer thread: produced {0} items", count);
    }
    private Queue<int> _queue;
    private SyncEvents _syncEvents;
}

// The Consumer class uses its own worker thread to consume items
// in the queue. The Producer class notifies the Consumer class
// of new items with the NewItemEvent.
public class Consumer
{
    public Consumer(Queue<int> q, SyncEvents e)
    {
        _queue = q;
        _syncEvents = e;
    }
    public void ThreadRun()
    {
        int count = 0;
        while (WaitHandle.WaitAny(_syncEvents.EventArray) != 1)
        {
            lock (((ICollection)_queue).SyncRoot)
            {
                int item = _queue.Dequeue();
            }
            count++;
        }
        Console.WriteLine("Consumer Thread: consumed {0} items", count);
    }
    private Queue<int> _queue;
    private SyncEvents _syncEvents;
}

public class ThreadSyncSample
{
    private static void ShowQueueContents(Queue<int> q)
    {
        // Enumerating a collection is inherently not thread-safe,
        // so it is imperative that the collection be locked throughout
        // the enumeration to prevent the consumer and producer threads
        // from modifying the contents. (This method is called by the
        // primary thread only.)
        lock (((ICollection)q).SyncRoot)
        {
            foreach (int i in q)
            {
                Console.Write("{0} ", i);
            }
        }
        Console.WriteLine();
    }

    static void Main()
    {
        // Configure struct containing event information required
        // for thread synchronization. 
        SyncEvents syncEvents = new SyncEvents();

        // Generic Queue collection is used to store items to be 
        // produced and consumed. In this case 'int' is used.
        Queue<int> queue = new Queue<int>();

        // Create objects, one to produce items, and one to 
        // consume. The queue and the thread synchronization
        // events are passed to both objects.
        Console.WriteLine("Configuring worker threads...");
        Producer producer = new Producer(queue, syncEvents);
        Consumer consumer = new Consumer(queue, syncEvents);

        // Create the thread objects for producer and consumer
        // objects. This step does not create or launch the
        // actual threads.
        Thread producerThread = new Thread(producer.ThreadRun);
        Thread consumerThread = new Thread(consumer.ThreadRun);

        // Create and launch both threads.     
        Console.WriteLine("Launching producer and consumer threads...");        
        producerThread.Start();
        consumerThread.Start();

        // Let producer and consumer threads run for 10 seconds.
        // Use the primary thread (the thread executing this method)
        // to display the queue contents every 2.5 seconds.
        for (int i = 0; i < 4; i++)
        {
            Thread.Sleep(2500);
            ShowQueueContents(queue);
        }

        // Signal both consumer and producer thread to terminate.
        // Both threads will respond because ExitThreadEvent is a 
        // manual-reset event--so it stays 'set' unless explicitly reset.
        Console.WriteLine("Signaling threads to terminate...");
        syncEvents.ExitThreadEvent.Set();

        // Use Join to block primary thread, first until the producer thread
        // terminates, then until the consumer thread terminates.
        Console.WriteLine("main thread waiting for threads to finish...");
        producerThread.Join();
        consumerThread.Join();
    }
}

Answer 7

ويرجى أن نضع في اعتبارنا أن يقفل في التعليمات البرمجية الدعوة قد يكون الخيار الأفضل إذا كان لديك السيطرة الكاملة على ذلك. النظر في الحصول على قائمة الانتظار في حلقة: عليك أن تكون الحصول داع أقفال عدة مرات، ويحتمل أن يترتب على عقوبة الأداء