Nessun ConcurrentList <T> in .Net 4.0?

Ero entusiasta di vedere il nuovo System.Collections.Concurrentspazio dei nomi in .Net 4.0, abbastanza bello! Ho visto ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBage BlockingCollection.

Una cosa che sembra misteriosamente mancante è a ConcurrentList<T>. Devo scriverlo da solo (o toglierlo dal web :))?

Mi sto perdendo qualcosa di ovvio qui?

Ci ho provato qualche tempo fa (anche: su GitHub ). La mia implementazione ha avuto alcuni problemi, che non entrerò qui. Lascia che ti dica, soprattutto, cosa ho imparato.

In primo luogo, non è possibile ottenere un'implementazione completa di IList<T>questo senza blocco e thread-safe. In particolare, gli inserimenti e le rimozioni casuali non funzioneranno, a meno che non dimentichi anche l'accesso casuale O (1) (cioè, a meno che tu non "imbroglia" e usi semplicemente una sorta di elenco collegato e lasci che l'indicizzazione faccia schifo).

Quello che ho pensato che potrebbe essere utile è stato un thread-safe, sottoinsieme limitato di IList<T>: in particolare, quella che avrebbe permesso una Adde fornire casuali di sola lettura l'accesso da parte di indice (ma no Insert, RemoveAte così via, e anche non casuale in scrittura accesso).

Questo era l'obiettivo della mia ConcurrentList<T>implementazione . Ma quando ho testato le sue prestazioni in scenari multithread, ho scoperto che semplicemente sincronizzare l'aggiunta con una List<T>era più veloce . Fondamentalmente, l'aggiunta a a List<T>è già velocissima; la complessità dei passaggi computazionali coinvolti è minuscola (incrementa un indice e assegna a un elemento in un array; tutto qui ). Avresti bisogno di un sacco di scritture simultanee per vedere qualsiasi tipo di contesa di blocco su questo; e anche in questo caso, le prestazioni medie di ogni scrittura eliminerebbero comunque l'implementazione più costosa sebbene senza lock in ConcurrentList<T>.

Nel caso relativamente raro che l'array interno dell'elenco debba ridimensionarsi, si paga un piccolo costo. Quindi alla fine ho concluso che questo era uno scenario di nicchia in cui ConcurrentList<T>avrebbe avuto senso un tipo di raccolta solo aggiunta : quando si desidera garantire un basso sovraccarico di aggiunta di un elemento su ogni singola chiamata (quindi, al contrario di un obiettivo di prestazione ammortizzato).

Semplicemente non è affatto utile una classe come si potrebbe pensare.

Per cosa useresti una ConcurrentList?

Il concetto di contenitore ad accesso casuale in un mondo thread non è così utile come potrebbe apparire. La dichiarazione

  if (i < MyConcurrentList.Count)  
      x = MyConcurrentList[i]; 

nel suo insieme non sarebbe ancora sicuro per i thread.

Invece di creare una ConcurrentList, prova a creare soluzioni con quello che c'è. Le classi più comuni sono ConcurrentBag e soprattutto BlockingCollection.

Con tutto il dovuto rispetto per le grandi risposte già fornite, ci sono volte in cui voglio semplicemente un IList thread-safe. Niente di avanzato o di fantasia. Le prestazioni sono importanti in molti casi, ma a volte questo non è un problema. Sì, ci saranno sempre sfide senza metodi come "TryGetValue", ecc., Ma nella maggior parte dei casi voglio solo qualcosa che posso enumerare senza dovermi preoccupare di mettere i blocchi intorno a tutto. E sì, qualcuno può probabilmente trovare qualche "bug" nella mia implementazione che potrebbe portare a un deadlock o qualcosa del genere (suppongo) ma siamo onesti: quando si tratta di multi-threading, se non si scrive correttamente il codice, esso sta andando comunque a un punto morto. Con questo in mente, ho deciso di realizzare una semplice implementazione ConcurrentList che fornisce queste esigenze di base.

E per quello che vale: ho fatto un test di base per aggiungere 10.000.000 di articoli a List e ConcurrentList regolari e i risultati sono stati:

Elenco completato in: 7793 millisecondi. Concorrente finito in: 8064 millisecondi.

public class ConcurrentList<T> : IList<T>, IDisposable
{
    #region Fields
    private readonly List<T> _list;
    private readonly ReaderWriterLockSlim _lock;
    #endregion

    #region Constructors
    public ConcurrentList()
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>();
    }

    public ConcurrentList(int capacity)
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>(capacity);
    }

    public ConcurrentList(IEnumerable<T> items)
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>(items);
    }
    #endregion

    #region Methods
    public void Add(T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.Add(item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public void Insert(int index, T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.Insert(index, item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public bool Remove(T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            return this._list.Remove(item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public void RemoveAt(int index)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.RemoveAt(index);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public int IndexOf(T item)
    {
        try
        {
            this._lock.EnterReadLock();
            return this._list.IndexOf(item);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

    public void Clear()
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.Clear();
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public bool Contains(T item)
    {
        try
        {
            this._lock.EnterReadLock();
            return this._list.Contains(item);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        try
        {
            this._lock.EnterReadLock();
            this._list.CopyTo(array, arrayIndex);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(this._list, this._lock);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(this._list, this._lock);
    }

    ~ConcurrentList()
    {
        this.Dispose(false);
    }

    public void Dispose()
    {
        this.Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if (disposing)
            GC.SuppressFinalize(this);

        this._lock.Dispose();
    }
    #endregion

    #region Properties
    public T this[int index]
    {
        get
        {
            try
            {
                this._lock.EnterReadLock();
                return this._list[index];
            }
            finally
            {
                this._lock.ExitReadLock();
            }
        }
        set
        {
            try
            {
                this._lock.EnterWriteLock();
                this._list[index] = value;
            }
            finally
            {
                this._lock.ExitWriteLock();
            }
        }
    }

    public int Count
    {
        get
        {
            try
            {
                this._lock.EnterReadLock();
                return this._list.Count;
            }
            finally
            {
                this._lock.ExitReadLock();
            }
        }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }
    #endregion
}

    public class ConcurrentEnumerator<T> : IEnumerator<T>
{
    #region Fields
    private readonly IEnumerator<T> _inner;
    private readonly ReaderWriterLockSlim _lock;
    #endregion

    #region Constructor
    public ConcurrentEnumerator(IEnumerable<T> inner, ReaderWriterLockSlim @lock)
    {
        this._lock = @lock;
        this._lock.EnterReadLock();
        this._inner = inner.GetEnumerator();
    }
    #endregion

    #region Methods
    public bool MoveNext()
    {
        return _inner.MoveNext();
    }

    public void Reset()
    {
        _inner.Reset();
    }

    public void Dispose()
    {
        this._lock.ExitReadLock();
    }
    #endregion

    #region Properties
    public T Current
    {
        get { return _inner.Current; }
    }

    object IEnumerator.Current
    {
        get { return _inner.Current; }
    }
    #endregion
}

ConcurrentList(come un array ridimensionabile, non un elenco collegato) non è facile da scrivere con operazioni non bloccanti. La sua API non si traduce bene in una versione "concorrente".

Il motivo per cui non esiste una ConcurrentList è perché fondamentalmente non può essere scritto. Il motivo è che diverse operazioni importanti in IList si basano su indici e che semplicemente non funzionerà. Per esempio:

int catIndex = list.IndexOf("cat");
list.Insert(catIndex, "dog");

L'effetto che l'autore sta cercando è di inserire "cane" prima di "gatto", ma in un ambiente multithread, tutto può succedere all'elenco tra quelle due righe di codice. Ad esempio, potrebbe fare un altro thread list.RemoveAt(0), spostando l'intero elenco a sinistra, ma soprattutto, catIndex non cambierà. L'impatto qui è che l' Insertoperazione metterà effettivamente il "cane" dopo il gatto, non prima di esso.

Le diverse implementazioni che vedi offerte come "risposte" a questa domanda sono ben intenzionate, ma come mostra quanto sopra, non offrono risultati affidabili. Se vuoi davvero una semantica simile a una lista in un ambiente multithread, non puoi arrivarci inserendo i blocchi all'interno dei metodi di implementazione della lista. Devi assicurarti che qualsiasi indice che usi risieda interamente nel contesto del blocco. Il risultato è che puoi usare una Lista in un ambiente multithread con il giusto blocco, ma la lista stessa non può essere fatta esistere in quel mondo.

Se pensi di aver bisogno di un elenco simultaneo, ci sono davvero solo due possibilità:

1. Ciò di cui hai veramente bisogno è un ConcurrentBag
2. Devi creare la tua raccolta, magari implementata con un elenco e il tuo controllo di concorrenza.

Se hai un ConcurrentBag e sei in una posizione in cui devi passarlo come IList, allora hai un problema, perché il metodo che stai chiamando ha specificato che potrebbero provare a fare qualcosa come ho fatto sopra con il gatto & cane. Nella maggior parte dei mondi, ciò significa che il metodo che stai chiamando non è semplicemente progettato per funzionare in un ambiente multi-thread. Ciò significa che lo rifattrai in modo che sia o, se non puoi, dovrai gestirlo con molta attenzione. Quasi sicuramente ti verrà richiesto di creare la tua raccolta con i suoi blocchi e chiamare il metodo offensivo all'interno di un blocco.

Nei casi in cui le letture superano di molto le scritture o le scritture (per quanto frequenti) non siano simultanee , può essere appropriato un approccio di copia su scrittura .

L'implementazione mostrata di seguito è

• lockless
• incredibilmente veloce per letture simultanee , anche mentre sono in corso modifiche simultanee - non importa quanto tempo impiegano
• perché gli "snapshot" sono immutabili, l'atomicità senza blocco è possibile, cioè var snap = _list; snap[snap.Count - 1];non verrà mai (beh, tranne per un elenco vuoto ovviamente), e otterrai anche un elenco thread-safe con semantica di snapshot gratis .. come ADORO l'immutabilità!
• implementato genericamente , applicabile a qualsiasi struttura di dati e qualsiasi tipo di modifica
• semplice , cioè facile da testare, eseguire il debug, verificare leggendo il codice
• utilizzabile in .Net 3.5

Affinché copy-on-write funzioni, è necessario mantenere le strutture dei dati effettivamente immutabili , ovvero nessuno è autorizzato a modificarle dopo averle rese disponibili per altri thread. Quando vuoi modificare, tu

1. clonare la struttura
2. apportare modifiche al clone
3. scambiare atomicamente il riferimento al clone modificato

Codice

static class CopyOnWriteSwapper
{
    public static void Swap<T>(ref T obj, Func<T, T> cloner, Action<T> op)
        where T : class
    {
        while (true)
        {
            var objBefore = Volatile.Read(ref obj);
            var newObj = cloner(objBefore);
            op(newObj);
            if (Interlocked.CompareExchange(ref obj, newObj, objBefore) == objBefore)
                return;
        }
    }
}

uso

CopyOnWriteSwapper.Swap(ref _myList,
    orig => new List<string>(orig),
    clone => clone.Add("asdf"));

Se hai bisogno di maggiori prestazioni, ti aiuterà a non rigenerare il metodo, ad es. Crea un metodo per ogni tipo di modifica (Aggiungi, Rimuovi, ...) che desideri, e codifica i puntatori di funzione clonere op.

NB # 1 È responsabilità dell'utente assicurarsi che nessuno modifichi la struttura (presumibilmente) immutabile dei dati. Non c'è nulla che possiamo fare in un'implementazione generica per evitarlo , ma quando ti specializzi a List<T>, potresti proteggerti dalle modifiche usando List.AsReadOnly ()

NB # 2 Prestare attenzione ai valori nell'elenco. L'approccio copy on write sopra protegge solo l'appartenenza all'elenco, ma se non inserissi stringhe, ma alcuni altri oggetti mutabili, devi occuparti della sicurezza del thread (ad esempio il blocco). Ma questo è ortogonale a questa soluzione e, ad esempio, il blocco dei valori mutabili può essere facilmente utilizzato senza problemi. Devi solo esserne consapevole.

NB # 3 Se la struttura dei dati è enorme e la si modifica frequentemente, l'approccio copia su scrittura potrebbe essere proibitivo sia in termini di consumo di memoria che di costo della CPU per la copia. In tal caso, potresti voler utilizzare invece le raccolte immutabili di MS .

System.Collections.Generic.List<t>è già thread-safe per più lettori. Cercare di rendere il thread sicuro per più autori non avrebbe senso. (Per motivi già menzionati da Henk e Stephen)

Alcune persone hanno oscurato alcuni punti merce (e alcuni dei miei pensieri):

• Potrebbe sembrare folle per impossibile accedere casualmente (indicizzatore) ma a me sembra bene. Devi solo pensare che ci sono molti metodi su raccolte multi-thread che potrebbero fallire come Indexer ed Delete. È inoltre possibile definire un'azione di errore (fallback) per l'accessor di scrittura come "fail" o semplicemente "aggiungi alla fine".
• Non è perché è una raccolta multithread che verrà sempre utilizzata in un contesto multithread. Oppure potrebbe essere utilizzato anche da un solo scrittore e un lettore.
• Un altro modo per essere in grado di utilizzare l'indicizzatore in modo sicuro potrebbe essere quello di avvolgere le azioni in un blocco della raccolta usando la sua radice (se resa pubblica).
• Per molte persone, rendere visibile un rootLock diventa una buona pratica. Non sono sicuro al 100% su questo punto perché se è nascosto rimuovi molta flessibilità all'utente. Dobbiamo sempre ricordare che la programmazione del multithread non è per nessuno. Non possiamo impedire ogni tipo di utilizzo errato.
• Microsoft dovrà fare un po 'di lavoro e definire alcuni nuovi standard per introdurre il corretto utilizzo della raccolta multithread. Innanzitutto IEnumerator non dovrebbe avere moveNext ma dovrebbe avere GetNext che restituisca true o false e ottenga un parametro di tipo T (in questo modo l'iterazione non bloccherebbe più). Inoltre, Microsoft già utilizza "utilizza" internamente in foreach ma a volte utilizza direttamente IEnumerator senza racchiuderlo in "using" (un bug nella vista raccolta e probabilmente in più punti) - L'utilizzo di IEnumerator nel wrapping è una pratica consigliata da Microsoft. Questo bug rimuove un buon potenziale per un iteratore sicuro ... Iteratore che blocca la raccolta nel costruttore e si sblocca sul suo metodo Dispose - per un metodo foreach di blocco.

Questa non è una risposta. Questi sono solo commenti che non si adattano realmente a un luogo specifico.

... La mia conclusione, Microsoft deve apportare alcune profonde modifiche al "foreach" per rendere la raccolta MultiThreaded più facile da usare. Inoltre deve seguire le proprie regole di utilizzo di IEnumerator. Fino a quel momento, possiamo scrivere facilmente una MultiThreadList che utilizzerebbe un iteratore di blocco ma che non seguirà "IList". Dovrai invece definire la propria interfaccia "IListPersonnal" che potrebbe non riuscire su "insert", "remove" e accessor casuale (indicizzatore) senza eccezioni. Ma chi vorrà usarlo se non è standard?

Nell'esecuzione sequenziale del codice le strutture di dati utilizzate sono diverse dal codice (ben scritto) che esegue contemporaneamente. Il motivo è che il codice sequenziale implica un ordine implicito. Il codice concorrente tuttavia non implica alcun ordine; meglio ancora implica la mancanza di un ordine definito!

A causa di ciò, le strutture di dati con ordine implicito (come Elenco) non sono molto utili per risolvere problemi simultanei. Un elenco implica ordine, ma non definisce chiaramente quale sia tale ordine. Per questo motivo l'ordine di esecuzione del codice che manipola l'elenco determinerà (in una certa misura) l'ordine implicito dell'elenco, che è in conflitto diretto con un'efficace soluzione concorrente.

Ricorda che la concorrenza è un problema di dati, non un problema di codice! Non è possibile implementare prima il codice (o riscrivere il codice sequenziale esistente) e ottenere una soluzione concorrente ben progettata. È necessario progettare prima le strutture di dati tenendo presente che l'ordinamento implicito non esiste in un sistema concorrente.

l'approccio Lockless Copy and Write funziona alla grande se non hai a che fare con troppi elementi. Ecco una lezione che ho scritto:

public class CopyAndWriteList<T>
{
    public static List<T> Clear(List<T> list)
    {
        var a = new List<T>(list);
        a.Clear();
        return a;
    }

    public static List<T> Add(List<T> list, T item)
    {
        var a = new List<T>(list);
        a.Add(item);
        return a;
    }

    public static List<T> RemoveAt(List<T> list, int index)
    {
        var a = new List<T>(list);
        a.RemoveAt(index);
        return a;
    }

    public static List<T> Remove(List<T> list, T item)
    {
        var a = new List<T>(list);
        a.Remove(item);
        return a;
    }

}

esempio di utilizzo: ordini_BUY = CopyAndWriteList.Clear (ordini_BUY);

Ne ho implementato uno simile a quello di Brian . Il mio è diverso:

• Gestisco direttamente l'array.
• Non inserisco i blocchi all'interno del blocco try.
• Uso yield returnper produrre un enumeratore.
• Sostengo la ricorsione del blocco. Ciò consente di leggere dall'elenco durante l'iterazione.
• Uso i blocchi di lettura aggiornabili ove possibile.
• DoSynce GetSyncmetodi che consentono interazioni sequenziali che richiedono l'accesso esclusivo all'elenco.

Il codice :

public class ConcurrentList<T> : IList<T>, IDisposable
{
    private ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
    private int _count = 0;

    public int Count
    {
        get
        { 
            _lock.EnterReadLock();
            try
            {           
                return _count;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }
    }

    public int InternalArrayLength
    { 
        get
        { 
            _lock.EnterReadLock();
            try
            {           
                return _arr.Length;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }
    }

    private T[] _arr;

    public ConcurrentList(int initialCapacity)
    {
        _arr = new T[initialCapacity];
    }

    public ConcurrentList():this(4)
    { }

    public ConcurrentList(IEnumerable<T> items)
    {
        _arr = items.ToArray();
        _count = _arr.Length;
    }

    public void Add(T item)
    {
        _lock.EnterWriteLock();
        try
        {       
            var newCount = _count + 1;          
            EnsureCapacity(newCount);           
            _arr[_count] = item;
            _count = newCount;                  
        }
        finally
        {
            _lock.ExitWriteLock();
        }       
    }

    public void AddRange(IEnumerable<T> items)
    {
        if (items == null)
            throw new ArgumentNullException("items");

        _lock.EnterWriteLock();

        try
        {           
            var arr = items as T[] ?? items.ToArray();          
            var newCount = _count + arr.Length;
            EnsureCapacity(newCount);           
            Array.Copy(arr, 0, _arr, _count, arr.Length);       
            _count = newCount;
        }
        finally
        {
            _lock.ExitWriteLock();          
        }
    }

    private void EnsureCapacity(int capacity)
    {   
        if (_arr.Length >= capacity)
            return;

        int doubled;
        checked
        {
            try
            {           
                doubled = _arr.Length * 2;
            }
            catch (OverflowException)
            {
                doubled = int.MaxValue;
            }
        }

        var newLength = Math.Max(doubled, capacity);            
        Array.Resize(ref _arr, newLength);
    }

    public bool Remove(T item)
    {
        _lock.EnterUpgradeableReadLock();

        try
        {           
            var i = IndexOfInternal(item);

            if (i == -1)
                return false;

            _lock.EnterWriteLock();
            try
            {   
                RemoveAtInternal(i);
                return true;
            }
            finally
            {               
                _lock.ExitWriteLock();
            }
        }
        finally
        {           
            _lock.ExitUpgradeableReadLock();
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        _lock.EnterReadLock();

        try
        {    
            for (int i = 0; i < _count; i++)
                // deadlocking potential mitigated by lock recursion enforcement
                yield return _arr[i]; 
        }
        finally
        {           
            _lock.ExitReadLock();
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    public int IndexOf(T item)
    {
        _lock.EnterReadLock();
        try
        {   
            return IndexOfInternal(item);
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }

    private int IndexOfInternal(T item)
    {
        return Array.FindIndex(_arr, 0, _count, x => x.Equals(item));
    }

    public void Insert(int index, T item)
    {
        _lock.EnterUpgradeableReadLock();

        try
        {                       
            if (index > _count)
                throw new ArgumentOutOfRangeException("index"); 

            _lock.EnterWriteLock();
            try
            {       
                var newCount = _count + 1;
                EnsureCapacity(newCount);

                // shift everything right by one, starting at index
                Array.Copy(_arr, index, _arr, index + 1, _count - index);

                // insert
                _arr[index] = item;     
                _count = newCount;
            }
            finally
            {           
                _lock.ExitWriteLock();
            }
        }
        finally
        {
            _lock.ExitUpgradeableReadLock();            
        }


    }

    public void RemoveAt(int index)
    {   
        _lock.EnterUpgradeableReadLock();
        try
        {   
            if (index >= _count)
                throw new ArgumentOutOfRangeException("index");

            _lock.EnterWriteLock();
            try
            {           
                RemoveAtInternal(index);
            }
            finally
            {
                _lock.ExitWriteLock();
            }
        }
        finally
        {
            _lock.ExitUpgradeableReadLock();            
        }
    }

    private void RemoveAtInternal(int index)
    {           
        Array.Copy(_arr, index + 1, _arr, index, _count - index-1);
        _count--;

        // release last element
        Array.Clear(_arr, _count, 1);
    }

    public void Clear()
    {
        _lock.EnterWriteLock();
        try
        {        
            Array.Clear(_arr, 0, _count);
            _count = 0;
        }
        finally
        {           
            _lock.ExitWriteLock();
        }   
    }

    public bool Contains(T item)
    {
        _lock.EnterReadLock();
        try
        {   
            return IndexOfInternal(item) != -1;
        }
        finally
        {           
            _lock.ExitReadLock();
        }
    }

    public void CopyTo(T[] array, int arrayIndex)
    {       
        _lock.EnterReadLock();
        try
        {           
            if(_count > array.Length - arrayIndex)
                throw new ArgumentException("Destination array was not long enough.");

            Array.Copy(_arr, 0, array, arrayIndex, _count);
        }
        finally
        {
            _lock.ExitReadLock();           
        }
    }

    public bool IsReadOnly
    {   
        get { return false; }
    }

    public T this[int index]
    {
        get
        {
            _lock.EnterReadLock();
            try
            {           
                if (index >= _count)
                    throw new ArgumentOutOfRangeException("index");

                return _arr[index]; 
            }
            finally
            {
                _lock.ExitReadLock();               
            }           
        }
        set
        {
            _lock.EnterUpgradeableReadLock();
            try
            {

                if (index >= _count)
                    throw new ArgumentOutOfRangeException("index");

                _lock.EnterWriteLock();
                try
                {                       
                    _arr[index] = value;
                }
                finally
                {
                    _lock.ExitWriteLock();              
                }
            }
            finally
            {
                _lock.ExitUpgradeableReadLock();
            }

        }
    }

    public void DoSync(Action<ConcurrentList<T>> action)
    {
        GetSync(l =>
        {
            action(l);
            return 0;
        });
    }

    public TResult GetSync<TResult>(Func<ConcurrentList<T>,TResult> func)
    {
        _lock.EnterWriteLock();
        try
        {           
            return func(this);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }

    public void Dispose()
    {   
        _lock.Dispose();
    }
}