Brak ConcurrentList <T> w .Net 4.0?

Byłem zachwycony, widząc nową System.Collections.Concurrentprzestrzeń nazw w .Net 4.0, całkiem fajnie! Widziałem ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBagi BlockingCollection.

Jedną z rzeczy, której wydaje się być tajemniczo brakuje, jest ConcurrentList<T>. Czy sam muszę to napisać (lub pobrać z Internetu :))?

Czy brakuje mi czegoś oczywistego?

I spróbowaliśmy jakiś czas temu (też: na GitHub ). Moja implementacja miała pewne problemy, o których nie będę tutaj wchodził. Co ważniejsze, powiem ci, czego się nauczyłem.

Po pierwsze, nie ma możliwości, aby uzyskać pełną implementację IList<T>tego bez blokady i wątków. W szczególności losowe wstawianie i usuwanie nie będzie działać, chyba że zapomnisz także o losowym dostępie O (1) (tj. Chyba że „oszukasz” i po prostu użyjesz jakiejś połączonej listy i pozwolisz indeksacji ssać).

Co ja pomyślałem może być wart był bezpieczny wątku, ograniczony podzbiór IList<T>: w szczególności taki, który pozwala osobie Addi zapewnić losową tylko do odczytu dostępu indeksu (ale nie Insert, RemoveAtitp, a także nie przypadkowy zapisu dostępu).

To był cel mojej ConcurrentList<T>realizacji . Ale kiedy przetestowałem jego wydajność w scenariuszach wielowątkowych, stwierdziłem, że zwykła synchronizacja dodaje do a List<T>była szybsza . Zasadniczo dodawanie do List<T>jest już błyskawiczne; złożoność zaangażowanych kroków obliczeniowych jest niewielka (zwiększ indeks i przypisz elementowi tablicy; to naprawdę tyle ). Byś potrzebował mnóstwo jednoczesnych zapisów zobaczyć jakiejkolwiek blokady niezgody na ten temat; i nawet wtedy średnia wydajność każdego zapisu nadal przewyższałaby droższą, choć bez blokady, implementację ConcurrentList<T>.

W stosunkowo rzadkim przypadku, gdy wewnętrzna tablica listy musi się zmienić, płacisz niewielki koszt. W końcu doszedłem do wniosku, że był to jedyny niszowy scenariusz, w którym ConcurrentList<T>typ kolekcji tylko do dodania miałby sens: gdy chcesz zagwarantować niski koszt dodawania elementu przy każdym pojedynczym wywołaniu (w przeciwieństwie do zamortyzowanego celu wydajności).

To po prostu nie jest tak przydatna klasa, jak mogłoby się wydawać.

Do czego użyłbyś ConcurrentList?

Koncepcja kontenera o dostępie swobodnym w świecie wątków nie jest tak przydatna, jak może się wydawać. Twierdzenie

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

jako całość nadal nie byłaby bezpieczna dla wątków.

Zamiast tworzyć ConcurrentList, spróbuj budować rozwiązania z tym, co tam jest. Najpopularniejsze klasy to ConcurrentBag, a zwłaszcza BlockingCollection.

Z całym szacunkiem dla już udzielonych wspaniałych odpowiedzi, czasami po prostu chcę bezpiecznej dla wątków IList. Nic zaawansowanego ani wymyślnego. Wydajność jest ważna w wielu przypadkach, ale czasami nie stanowi to problemu. Tak, zawsze będą wyzwania bez metod takich jak „TryGetValue” itp., Ale w większości przypadków chcę tylko czegoś, co mogę wymienić bez konieczności martwienia się o blokowanie wszystkiego. I tak, ktoś prawdopodobnie może znaleźć „błąd” w mojej implementacji, który może doprowadzić do impasu lub czegoś (przypuszczam), ale bądźmy szczerzy: jeśli chodzi o wielowątkowość, jeśli nie napiszesz poprawnie kodu, to i tak jest w impasie. Mając to na uwadze, postanowiłem wykonać prostą implementację ConcurrentList, która zaspokoi te podstawowe potrzeby.

I za to, co warto: wykonałem podstawowy test dodania 10 000 000 pozycji do zwykłej listy i listy współbieżnych, a wyniki były następujące:

Lista zakończona za: 7793 milisekundy. Współbieżne ukończone za: 8064 milisekund.

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(jako tablica o zmiennym rozmiarze, a nie połączona lista) nie jest łatwo pisać przy użyciu operacji nieblokujących. Jego interfejs API nie przekłada się dobrze na wersję „współbieżną”.

Powodem, dla którego nie ma ConcurrentList, jest to, że zasadniczo nie można go zapisać. Powodem jest to, że kilka ważnych operacji w IList opiera się na indeksach i po prostu nie działa. Na przykład:

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

Efektem, do którego dąży autor, jest wstawienie „pies” przed „kot”, ale w środowisku wielowątkowym wszystko może się zdarzyć na liście między tymi dwoma wierszami kodu. Na przykład mógłby zrobić inny wątek list.RemoveAt(0), przesuwając całą listę w lewo, ale co najważniejsze, catIndex się nie zmieni. Wpływ na to jest taki, że Insertoperacja spowoduje umieszczenie „psa” za kotem, a nie przed nim.

Kilka implementacji, które widzisz jako „odpowiedzi” na to pytanie, ma dobre intencje, ale jak pokazuje powyższy, nie oferują wiarygodnych wyników. Jeśli naprawdę chcesz semantyki podobnej do listy w środowisku wielowątkowym, nie możesz się tam dostać, umieszczając blokady w metodach implementacji listy. Musisz upewnić się, że każdy indeks, którego używasz, działa całkowicie w kontekście blokady. Rezultatem jest to, że możesz używać Listy w środowisku wielowątkowym z właściwym blokowaniem, ale sama lista nie może istnieć w tym świecie.

Jeśli uważasz, że potrzebujesz współbieżnej listy, istnieją naprawdę tylko dwie możliwości:

1. Tak naprawdę potrzebujesz ConcurrentBag
2. Musisz stworzyć własną kolekcję, być może zaimplementowaną z Listą i własną kontrolą współbieżności.

Jeśli masz ConcurrentBag i jesteś w pozycji, w której musisz przekazać go jako IList, masz problem, ponieważ wywoływana metoda określa, że ​​mogą spróbować zrobić coś takiego jak ja powyżej z cat & pies. W większości światów oznacza to, że metoda, którą wywołujesz, po prostu nie jest zbudowana do pracy w środowisku wielowątkowym. Oznacza to, że albo przebudujesz go tak, aby był, albo, jeśli nie możesz, będziesz musiał obchodzić się z nim bardzo ostrożnie. Prawie na pewno będziesz musiał stworzyć własną kolekcję z własnymi zamkami i wywołać metodę obrażającą w obrębie zamka.

W przypadkach, gdy odczyty znacznie przewyższają liczbę zapisów lub (jakkolwiek częste) zapisy nie są współbieżne , odpowiednie może być podejście kopiowania przy zapisie .

Implementacja pokazana poniżej to

• bez zamka
• błyskawicznie szybki dla równoczesnych odczytów , nawet podczas jednoczesnych modyfikacji - bez względu na to, jak długo to zajmie
• ponieważ „migawki” są niezmienne, atomowość bez blokady jest możliwa, tzn. var snap = _list; snap[snap.Count - 1];nigdy (cóż, z wyjątkiem pustej listy oczywiście) nie rzuca, a także dostajesz bezpieczne wątkowo wyliczanie z semantyką migawek za darmo .. jak KOCHAM niezmienność!
• zaimplementowane ogólnie , mające zastosowanie do dowolnej struktury danych i każdego rodzaju modyfikacji
• bardzo prosty , tzn. łatwy do przetestowania, debugowania, weryfikacji poprzez odczytanie kodu
• do użytku w .Net 3.5

Aby kopiowanie przy zapisie działało, musisz utrzymywać swoje struktury danych w sposób niezmienny , tzn. Nikt nie może ich zmieniać po udostępnieniu ich innym wątkom. Kiedy chcesz zmodyfikować, ty

1. sklonuj strukturę
2. wprowadź zmiany w klonie
3. zamień atomowo w odniesieniu do zmodyfikowanego klonu

Kod

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;
        }
    }
}

Stosowanie

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

Jeśli potrzebujesz większej wydajności, pomoże to uogólnić metodę, np. Utwórz jedną metodę dla każdego rodzaju modyfikacji (dodaj, usuń, ...), którą chcesz, i zapisz wskaźniki funkcji cloneri op.

Uwaga nr 1 Twoim obowiązkiem jest upewnić się, że nikt nie modyfikuje (rzekomo) niezmiennej struktury danych. Nic nie możemy zrobić w ogólnej implementacji, aby temu zapobiec, ale specjalizując się w niej List<T>, możesz uchronić się przed modyfikacją za pomocą List.AsReadOnly ()

NB # 2 Uważaj na wartości z listy. Powyższe podejście do kopiowania chroni tylko ich członkostwo na liście, ale jeśli nie wstawisz ciągów, ale niektóre inne zmienne obiekty, musisz zadbać o bezpieczeństwo wątków (np. Blokowanie). Jest to jednak ortogonalne w stosunku do tego rozwiązania i np. Można zablokować zmienne wartości bez problemu. Musisz tylko być tego świadomy.

Uwaga nr 3 Jeśli struktura danych jest ogromna i często ją modyfikujesz, podejście kopiowania wszystkich danych w trakcie zapisu może być wygórowane zarówno pod względem zużycia pamięci, jak i kosztów procesora związanych z kopiowaniem. W takim przypadku możesz zamiast tego skorzystać z niezmiennych kolekcji MS .

System.Collections.Generic.List<t>jest już bezpieczny dla wielu czytelników. Próba uczynienia tego wątkiem bezpiecznym dla wielu pisarzy nie miałaby sensu. (Z powodów, o których wspominali już Henk i Stephen)

Niektórzy zauważyli niektóre punkty towarów (i niektóre z moich myśli):

• Może wyglądać na szaleństwo z powodu niemożności losowego dostępu (indeksatora), ale dla mnie wygląda to dobrze. Trzeba tylko pomyśleć, że istnieje wiele metod w kolekcjach wielowątkowych, które mogą zawieść, takie jak Indexer i Delete. Można również zdefiniować działanie powodujące awarię (zapis awaryjny) dla modułu zapisującego, takie jak „błąd” lub po prostu „dodaj na końcu”.
• Nie dlatego, że jest to kolekcja wielowątkowa, że ​​zawsze będzie używana w kontekście wielowątkowym. Lub może być również używany tylko przez jednego pisarza i jednego czytelnika.
• Innym sposobem na bezpieczne korzystanie z indeksatora może być zawinięcie akcji w blokadę kolekcji za pomocą jej katalogu głównego (jeśli zostanie podana do wiadomości publicznej).
• Dla wielu osób widoczność rootLocka brzmi „Dobra praktyka”. Nie jestem w 100% pewien co do tego punktu, ponieważ jeśli jest ukryty, usuwasz dużą elastyczność dla użytkownika. Zawsze musimy pamiętać, że programowanie wielowątkowości nie jest dla nikogo. Nie możemy zapobiec wszelkiego rodzaju niewłaściwemu użyciu.
• Microsoft będzie musiał popracować i zdefiniować nowy standard, aby wprowadzić prawidłowe użycie kolekcji wielowątkowej. Po pierwsze IEnumerator nie powinien mieć parametru moveNext, ale powinien mieć GetNext, który zwraca true lub false i uzyskuje parametr wyjściowy typu T (w ten sposób iteracja nie będzie już blokować). Ponadto Microsoft już używa „za pomocą” wewnętrznie w foreach, ale czasami używa bezpośrednio IEnumeratora bez owijania go za pomocą „za pomocą” (błąd w widoku kolekcji i prawdopodobnie w większej liczbie miejsc) - Korzystanie z IEnumeratora jest zalecane przez Microsoft. Ten błąd usuwa duży potencjał bezpiecznego iteratora ... Iterator, który blokuje kolekcję w konstruktorze i odblokowuje za pomocą metody Dispose - dla blokującej metody foreach.

To nie jest odpowiedź. To tylko komentarze, które tak naprawdę nie pasują do konkretnego miejsca.

... Mój wniosek, Microsoft musi wprowadzić głębokie zmiany w „foreach”, aby ułatwić korzystanie z kolekcji MultiThreaded. Musi również przestrzegać własnych zasad użytkowania IEnumerator. Do tego czasu możemy łatwo napisać MultiThreadList, który używałby iteratora blokującego, ale który nie byłby zgodny z „IList”. Zamiast tego będziesz musiał zdefiniować własny interfejs „IListPersonnal”, który może zawieść bez „wyjątku” przy „wstawianiu”, „usuwaniu” i przypadkowym akcesoriu (indeksatorze). Ale kto będzie chciał z niego korzystać, jeśli nie jest to standard?

W sekwencyjnie wykonywanym kodzie stosowane struktury danych różnią się od (dobrze napisanego) jednocześnie wykonującego się kodu. Powodem jest to, że kod sekwencyjny implikuje porządek niejawny. Współbieżny kod nie oznacza jednak żadnego zamówienia; jeszcze lepiej, implikuje to brak określonej kolejności!

Z tego powodu struktury danych z domyślną kolejnością (np. Lista) nie są zbyt przydatne do rozwiązywania równoczesnych problemów. Lista implikuje porządek, ale nie określa jasno, czym jest ta kolejność. Z tego powodu kolejność wykonywania kodu manipulującego listą określa (do pewnego stopnia) domyślną kolejność listy, która jest w bezpośrednim konflikcie z wydajnym rozwiązaniem współbieżnym.

Pamiętaj, że współbieżność to problem z danymi, a nie problem z kodem! Nie możesz najpierw zaimplementować kodu (lub przepisać istniejącego kodu sekwencyjnego) i uzyskać dobrze zaprojektowane współbieżne rozwiązanie. Najpierw musisz zaprojektować struktury danych, pamiętając o tym, że niejawne porządkowanie nie istnieje w systemie współbieżnym.

Bezblokowe kopiowanie i zapisywanie działa świetnie, jeśli nie masz do czynienia z zbyt dużą liczbą elementów. Oto klasa, którą napisałem:

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;
    }

}

przykładowe użycie: Orders_BUY = CopyAndWriteList.Clear (Orders_BUY);

Zaimplementowałem jeden podobny do Briana . Mój jest inny:

• Zarządzam tablicą bezpośrednio.
• Nie wprowadzam zamków w bloku try.
• Używam yield returndo tworzenia modułu wyliczającego.
• Obsługuję rekurencję blokady. Umożliwia to odczytywanie z listy podczas iteracji.
• Tam, gdzie to możliwe, używam blokad odczytu z możliwością aktualizacji.
• DoSyncoraz GetSyncmetody pozwalające na sekwencyjne interakcje wymagające wyłącznego dostępu do listy.

Kod :

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();
    }
}