Không có Danh sách đồng thời <T> trong .Net 4.0?

Tôi đã rất vui mừng khi thấy System.Collections.Concurrentkhông gian tên mới trong .Net 4.0, khá hay! Tôi đã nhìn thấy ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBagvà BlockingCollection.

Một thứ dường như bị mất tích một cách bí ẩn là a ConcurrentList<T>. Tôi có phải tự viết nó ra (hoặc lấy nó ra khỏi web :)) không?

Tôi có thiếu một cái gì đó rõ ràng ở đây?

Tôi đã thử lại một lúc (cũng: trên GitHub ). Việc thực hiện của tôi có một số vấn đề, mà tôi sẽ không nhận được ở đây. Hãy để tôi nói với bạn, quan trọng hơn, những gì tôi học được.

Thứ nhất, không có cách nào bạn có thể thực hiện đầy đủ IList<T> điều đó là không khóa và an toàn cho chuỗi. Cụ thể, các thao tác chèn và xóa ngẫu nhiên sẽ không hoạt động, trừ khi bạn cũng quên truy cập ngẫu nhiên O (1) (trừ khi bạn "gian lận" và chỉ sử dụng một số loại danh sách được liên kết và để cho việc lập chỉ mục hút).

Những gì tôi nghĩ có thể đáng giá là một tập hợp con giới hạn, an toàn của luồng IList<T>: cụ thể, một tập hợp cho phép Addvà cung cấp quyền truy cập chỉ đọc ngẫu nhiên theo chỉ mục (nhưng không Insert,RemoveAt vv, và cũng không ngẫu nhiên ghi truy cập).

Đây là mục tiêu thực hiện của tôiConcurrentList<T> . Nhưng khi tôi kiểm tra hiệu năng của nó trong các kịch bản đa luồng, tôi thấy rằng chỉ cần đồng bộ hóa thêm vào List<T>là nhanh hơn . Về cơ bản, thêm vào một List<T>là nhanh như chớp; độ phức tạp của các bước tính toán liên quan là rất nhỏ (tăng chỉ số và gán cho một phần tử trong một mảng; đó thực sự là nó ). Bạn sẽ cần một tấn ghi đồng thời để xem bất kỳ loại tranh chấp khóa nào về điều này; và thậm chí sau đó, hiệu suất trung bình của mỗi lần viết vẫn sẽ đánh bại việc triển khai không khóa đắt tiền hơn mặc dù ConcurrentList<T>.

Trong trường hợp tương đối hiếm mà mảng nội bộ của danh sách cần thay đổi kích thước, bạn phải trả một khoản chi phí nhỏ. Vì vậy, cuối cùng tôi đã kết luận rằng đây là một kịch bản thích hợp trong đó một ConcurrentList<T>loại bộ sưu tập chỉ thêm sẽ có ý nghĩa: khi bạn muốn được đảm bảo chi phí thấp cho việc thêm một yếu tố vào mỗi cuộc gọi (vì vậy, trái với mục tiêu hiệu suất được khấu hao).

Nó đơn giản không phải là một lớp học hữu ích như bạn nghĩ.

Bạn sẽ sử dụng một Danh sách đồng thời để làm gì?

Khái niệm về một thùng chứa Truy cập ngẫu nhiên trong một thế giới có luồng không hữu ích như nó có thể xuất hiện. Tuyên bố

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

như một toàn thể vẫn sẽ không được an toàn chủ đề.

Thay vì tạo một Danh sách đồng thời, hãy thử xây dựng các giải pháp với những gì có. Các lớp phổ biến nhất là ConcurrencyBag và đặc biệt là BlockingCollection.

Với tất cả sự tôn trọng đối với các câu trả lời tuyệt vời đã được cung cấp, có những lúc tôi chỉ muốn một IList an toàn theo chủ đề. Không có gì tiên tiến hoặc ưa thích. Hiệu suất là quan trọng trong nhiều trường hợp nhưng đôi khi đó không phải là một mối quan tâm. Vâng, luôn luôn có những thách thức mà không có phương pháp như "TryGetValue", v.v., nhưng hầu hết các trường hợp tôi chỉ muốn một cái gì đó mà tôi có thể liệt kê mà không cần phải lo lắng về việc khóa tất cả mọi thứ. Và vâng, ai đó có thể có thể tìm thấy một số "lỗi" trong quá trình triển khai của tôi có thể dẫn đến bế tắc hoặc một cái gì đó (tôi cho là vậy) nhưng hãy thành thật: Khi nói đến đa luồng, nếu bạn không viết mã chính xác, nó sẽ viết mã chính xác dù sao cũng sẽ bế tắc. Với ý nghĩ đó, tôi đã quyết định thực hiện một triển khai đồng thời đơn giản cung cấp các nhu cầu cơ bản này.

Và với giá trị của nó: Tôi đã thực hiện một thử nghiệm cơ bản về việc thêm 10.000.000 mục vào Danh sách thông thường và Danh sách đồng thời và kết quả là:

Danh sách kết thúc sau: 7793 mili giây. Đồng thời kết thúc sau: 8064 mili giây.

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(như một mảng có thể thay đổi kích thước, không phải là một danh sách được liên kết) không dễ viết với các hoạt động không chặn. API của nó không dịch tốt sang phiên bản "đồng thời".

Lý do tại sao không có Danh sách đồng thời là vì về cơ bản nó không thể được viết. Lý do tại sao một số hoạt động quan trọng trong IList dựa vào các chỉ số và điều đó hoàn toàn không hiệu quả. Ví dụ:

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

Hiệu ứng mà tác giả sẽ theo sau là chèn "dog" trước "cat", nhưng trong một môi trường đa luồng, bất cứ điều gì cũng có thể xảy ra với danh sách giữa hai dòng mã này. Ví dụ, một luồng khác có thể làm list.RemoveAt(0), chuyển toàn bộ danh sách sang trái, nhưng điều quan trọng nhất là cat Index sẽ không thay đổi. Tác động ở đây là Inserthoạt động sẽ thực sự đặt "con chó" sau con mèo chứ không phải trước nó.

Một số triển khai mà bạn thấy được cung cấp là "câu trả lời" cho câu hỏi này rất có ý nghĩa, nhưng như các chương trình trên, chúng không mang lại kết quả đáng tin cậy. Nếu bạn thực sự muốn ngữ nghĩa giống như danh sách trong một môi trường đa luồng, bạn không thể đến đó bằng cách đặt các khóa bên trong các phương thức thực hiện danh sách. Bạn phải đảm bảo rằng bất kỳ chỉ mục nào bạn sử dụng đều sống hoàn toàn bên trong bối cảnh của khóa. Kết quả cuối cùng là bạn có thể sử dụng Danh sách trong môi trường đa luồng với khóa đúng, nhưng bản thân danh sách không thể tồn tại trong thế giới đó.

Nếu bạn nghĩ rằng bạn cần một danh sách đồng thời, thực sự chỉ có hai khả năng:

1. Những gì bạn thực sự cần là một đồng thời
2. Bạn cần tạo bộ sưu tập của riêng mình, có thể được triển khai với Danh sách và kiểm soát đồng thời của riêng bạn.

Nếu bạn có một concallelBag và đang ở vị trí mà bạn cần vượt qua nó với tư cách là một IList, thì bạn có một vấn đề, bởi vì phương thức bạn đang gọi đã chỉ định rằng họ có thể cố gắng làm điều gì đó như tôi đã làm ở trên với con mèo & chó. Trong hầu hết các thế giới, điều đó có nghĩa là phương thức bạn gọi đơn giản là không được xây dựng để hoạt động trong môi trường đa luồng. Điều đó có nghĩa là bạn hoặc cấu trúc lại nó sao cho đúng hoặc nếu không thể, bạn sẽ phải xử lý nó rất cẩn thận. Bạn gần như chắc chắn sẽ được yêu cầu tạo bộ sưu tập của riêng mình bằng các khóa riêng và gọi phương thức vi phạm trong một khóa.

Trong trường hợp số lần đọc vượt quá số lần ghi, hoặc (tuy nhiên thường xuyên) việc ghi không đồng thời , cách tiếp cận sao chép trên ghi có thể phù hợp.

Việc thực hiện dưới đây là

• không khóa
• cực kỳ nhanh để đọc đồng thời , ngay cả khi các sửa đổi đồng thời đang diễn ra - bất kể chúng mất bao lâu
• bởi vì "ảnh chụp nhanh" là bất biến, nguyên tử không khóa là có thể, tức là var snap = _list; snap[snap.Count - 1];sẽ không bao giờ (tốt, ngoại trừ một danh sách trống tất nhiên), và bạn cũng nhận được liệt kê an toàn theo chủ đề với ngữ nghĩa chụp nhanh miễn phí .. làm thế nào tôi YÊU sự bất biến!
• triển khai rộng rãi , áp dụng cho mọi cấu trúc dữ liệu và mọi loại sửa đổi
• Chết đơn giản , dễ kiểm tra, gỡ lỗi, xác minh bằng cách đọc mã
• có thể sử dụng trong .Net 3.5

Để sao chép trên ghi hoạt động, bạn phải giữ cấu trúc dữ liệu của mình một cách hiệu quả bất biến , tức là không ai được phép thay đổi chúng sau khi bạn cung cấp chúng cho các luồng khác. Khi bạn muốn sửa đổi, bạn

1. nhân bản cấu trúc
2. sửa đổi trên bản sao
3. trao đổi nguyên tử trong tham chiếu đến bản sao được sửa đổi

Mã

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

Sử dụng

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

Nếu bạn cần hiệu năng cao hơn, nó sẽ giúp làm sáng tỏ phương thức, ví dụ: tạo một phương thức cho mọi loại sửa đổi (Thêm, Xóa, ...) bạn muốn và mã cứng các con trỏ hàm clonervà op.

NB # 1 Bạn có trách nhiệm đảm bảo không ai sửa đổi cấu trúc dữ liệu bất biến (được cho là). Không có gì chúng ta có thể làm trong một triển khai chung để ngăn chặn điều đó, nhưng khi chuyên môn hóa List<T>, bạn có thể bảo vệ chống lại sửa đổi bằng List.AsReadOnly ()

NB # 2 Hãy cẩn thận về các giá trị trong danh sách. Cách tiếp cận sao chép trên chỉ bảo vệ tư cách thành viên danh sách của họ, nhưng nếu bạn không đặt chuỗi, nhưng một số đối tượng có thể thay đổi khác trong đó, bạn phải quan tâm đến an toàn luồng (ví dụ: khóa). Nhưng đó là trực giao với giải pháp này và ví dụ: khóa các giá trị có thể thay đổi có thể dễ dàng sử dụng mà không gặp vấn đề gì. Bạn chỉ cần nhận thức được nó.

NB # 3 Nếu cấu trúc dữ liệu của bạn rất lớn và bạn sửa đổi nó thường xuyên, phương pháp sao chép toàn bộ ghi có thể bị cấm cả về mức tiêu thụ bộ nhớ và chi phí sao chép CPU liên quan. Trong trường hợp đó, bạn có thể muốn sử dụng Bộ sưu tập bất biến của MS thay thế.

System.Collections.Generic.List<t>đã là chủ đề an toàn cho nhiều người đọc. Cố gắng làm cho nó chủ đề an toàn cho nhiều nhà văn sẽ không có ý nghĩa. (Vì lý do Henk và Stephen đã đề cập)

Một số người che giấu một số điểm hàng hóa (và một số suy nghĩ của tôi):

• Nó có thể trông giống điên rồ khi không thể truy cập ngẫu nhiên (bộ chỉ mục) nhưng với tôi nó có vẻ ổn. Bạn chỉ cần nghĩ rằng có nhiều phương pháp trên các bộ sưu tập đa luồng có thể thất bại như Indexer và Delete. Bạn cũng có thể xác định hành động thất bại (dự phòng) cho trình truy cập ghi như "fail" hoặc đơn giản là "thêm vào cuối".
• Không phải vì nó là một bộ sưu tập đa luồng mà nó sẽ luôn được sử dụng trong bối cảnh đa luồng. Hoặc nó cũng chỉ có thể được sử dụng bởi một nhà văn và một người đọc.
• Một cách khác để có thể sử dụng bộ chỉ mục một cách an toàn có thể là bọc các hành động vào một khóa của bộ sưu tập bằng cách sử dụng gốc của nó (nếu được công khai).
• Đối với nhiều người, việc tạo một rootLock có thể nhìn thấy được là "Thực hành tốt". Tôi không chắc chắn 100% về điểm này bởi vì nếu nó bị ẩn, bạn sẽ loại bỏ rất nhiều tính linh hoạt cho người dùng. Chúng ta luôn phải nhớ rằng lập trình đa luồng không dành cho bất kỳ ai. Chúng tôi không thể ngăn chặn mọi loại sử dụng sai.
• Microsoft sẽ phải thực hiện một số công việc và xác định một số tiêu chuẩn mới để giới thiệu cách sử dụng hợp lý bộ sưu tập Đa luồng. Đầu tiên, IEnumerator không nên có moveNext mà nên có GetNext trả về true hoặc false và lấy tham số loại T (theo cách này, phép lặp sẽ không bị chặn nữa). Ngoài ra, Microsoft đã sử dụng "sử dụng" nội bộ trong foreach nhưng đôi khi sử dụng IEnumerator trực tiếp mà không gói nó bằng "bằng cách sử dụng" (một lỗi trong chế độ xem bộ sưu tập và có thể ở nhiều nơi hơn) - Việc sử dụng IEnumerator là một ưu tiên được khuyến nghị bởi Microsoft. Lỗi này loại bỏ tiềm năng tốt cho trình lặp an toàn ... Trình lặp đó khóa bộ sưu tập trong hàm tạo và mở khóa trên phương thức Vứt bỏ của nó - cho phương thức chặn foreach.

Đó không phải là một câu trả lời. Đây chỉ là những bình luận không thực sự phù hợp với một địa điểm cụ thể.

... Kết luận của tôi, Microsoft phải thực hiện một số thay đổi sâu sắc đối với "foreach" để làm cho bộ sưu tập MultiThreaded dễ sử dụng hơn. Ngoài ra, nó phải tuân theo các quy tắc sử dụng IEnumerator riêng. Cho đến lúc đó, chúng ta có thể viết MultiThreadList một cách dễ dàng sẽ sử dụng trình lặp chặn nhưng điều đó sẽ không tuân theo "IList". Thay vào đó, bạn sẽ phải xác định giao diện "IListPersonnal" riêng có thể không thành công khi "chèn", "xóa" và trình truy cập ngẫu nhiên (bộ chỉ mục) mà không có ngoại lệ. Nhưng ai sẽ muốn sử dụng nó nếu nó không chuẩn?

Trong mã thực thi tuần tự, các cấu trúc dữ liệu được sử dụng khác với mã thực thi đồng thời (được viết tốt). Lý do là mã tuần tự ngụ ý thứ tự ngầm. Mã đồng thời tuy nhiên không ngụ ý bất kỳ thứ tự nào; tốt hơn nữa nó ngụ ý việc thiếu bất kỳ trật tự được xác định!

Do đó, các cấu trúc dữ liệu với thứ tự ngụ ý (như Danh sách) không hữu ích cho việc giải quyết các vấn đề đồng thời. Một danh sách ngụ ý thứ tự, nhưng nó không xác định rõ thứ tự đó là gì. Do đó, thứ tự thực thi của mã thao tác danh sách sẽ xác định (ở một mức độ nào đó) thứ tự ngầm của danh sách, xung đột trực tiếp với một giải pháp đồng thời hiệu quả.

Hãy nhớ đồng thời là một vấn đề dữ liệu, không phải là một vấn đề mã! Bạn không thể triển khai mã trước (hoặc viết lại mã tuần tự hiện có) và có được một giải pháp đồng thời được thiết kế tốt. Bạn cần thiết kế cấu trúc dữ liệu trước trong khi lưu ý rằng thứ tự ngầm không tồn tại trong một hệ thống đồng thời.

Phương pháp sao chép và ghi không khóa hoạt động tốt nếu bạn không xử lý quá nhiều mục. Đây là một lớp tôi đã viết:

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

}

sử dụng ví dụ: order_BUY = CopyAndWriteList.Clear (order_BUY);

Tôi đã thực hiện một cái tương tự như của Brian . Của tôi là khác nhau:

• Tôi quản lý mảng trực tiếp.
• Tôi không nhập các ổ khóa trong khối thử.
• Tôi sử dụng yield returnđể sản xuất một điều tra viên.
• Tôi hỗ trợ đệ quy khóa. Điều này cho phép đọc từ danh sách trong quá trình lặp.
• Tôi sử dụng khóa đọc nâng cấp nếu có thể.
• DoSyncvà GetSynccác phương thức cho phép các tương tác tuần tự yêu cầu quyền truy cập độc quyền vào danh sách.

Mã :

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