Thuộc tính Danh sách <T> an toàn theo chuỗi

Tôi muốn triển khai List<T>như một thuộc tính có thể được sử dụng theo luồng một cách an toàn mà không nghi ngờ gì.

Một cái gì đó như thế này:

private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

Có vẻ như tôi vẫn cần trả lại một bản sao (nhân bản) của bộ sưu tập vì vậy nếu ở đâu đó chúng tôi đang lặp lại bộ sưu tập và đồng thời bộ sưu tập được thiết lập, thì không có ngoại lệ nào được nêu ra.

Làm thế nào để triển khai thuộc tính thu thập an toàn theo luồng?

Nếu bạn đang nhắm mục tiêu .Net 4, có một số tùy chọn trong System.Collections.Concurrent Namespace

Bạn có thể sử dụng ConcurrentBag<T>trong trường hợp này thay vìList<T>

Ngay cả khi nó nhận được nhiều phiếu bầu nhất, nó thường không thể được coi System.Collections.Concurrent.ConcurrentBag<T>là sự thay thế an toàn cho luồng System.Collections.Generic.List<T>vì nó vốn có (Radek Stromský đã chỉ ra nó) không được đặt hàng.

Nhưng có một lớp được gọi System.Collections.Generic.SynchronizedCollection<T>là đã có từ khi .NET 3.0 là một phần của khung công tác, nhưng nó ẩn rất nhiều ở một vị trí mà người ta không ngờ rằng nó ít được biết đến và có lẽ bạn chưa bao giờ tình cờ tìm thấy nó (ít nhất là Tôi không bao giờ làm).

SynchronizedCollection<T>được biên dịch thành assembly System.ServiceModel.dll (là một phần của hồ sơ khách nhưng không phải của thư viện lớp di động).

Hy vọng rằng sẽ giúp.

Tôi nghĩ rằng việc tạo một lớp ThreadSafeList mẫu sẽ dễ dàng:

public class ThreadSafeList<T> : IList<T>
{
    protected List<T> _interalList = new List<T>();

    // Other Elements of IList implementation

    public IEnumerator<T> GetEnumerator()
    {
        return Clone().GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return Clone().GetEnumerator();
    }

    protected static object _lock = new object();

    public List<T> Clone()
    {
        List<T> newList = new List<T>();

        lock (_lock)
        {
            _interalList.ForEach(x => newList.Add(x));
        }

        return newList;
    }
}

Bạn chỉ cần sao chép danh sách trước khi yêu cầu một điều tra viên, và do đó bất kỳ liệt kê nào cũng đang xử lý một bản sao không thể sửa đổi trong khi chạy.

Ngay cả câu trả lời được chấp nhận là ConcurrentBag, tôi không nghĩ rằng nó thực sự thay thế danh sách trong mọi trường hợp, như nhận xét của Radek cho câu trả lời cho biết: "ConcurrentBag là bộ sưu tập không có thứ tự, vì vậy không giống như List, nó không đảm bảo thứ tự. Ngoài ra, bạn không thể truy cập các mục theo chỉ mục ".

Vì vậy, nếu bạn sử dụng .NET 4.0 trở lên, giải pháp thay thế có thể là sử dụng ConcurrentDictionary với TKey số nguyên làm chỉ số mảng và TValue làm giá trị mảng. Đây là cách được đề xuất để thay thế danh sách trong khóa học Bộ sưu tập đồng thời C # của Pluralsight . ConcurrentDictionary giải quyết được cả hai vấn đề được đề cập ở trên: truy cập chỉ mục và sắp xếp thứ tự (chúng ta không thể dựa vào thứ tự vì đó là bảng băm, nhưng việc triển khai .NET hiện tại sẽ tiết kiệm thứ tự của các phần tử được thêm vào).

ArrayListLớp của C # có một Synchronizedphương thức.

var threadSafeArrayList = ArrayList.Synchronized(new ArrayList());

Điều này trả về một trình bao bọc an toàn luồng xung quanh bất kỳ trường hợp nào của IList. Tất cả các hoạt động cần được thực hiện thông qua trình bao bọc để đảm bảo an toàn cho luồng.

Nếu bạn nhìn vào mã nguồn của Danh sách T ( https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,c66df6f36c131877 ), bạn sẽ nhận thấy có một lớp ở đó (tất nhiên là nội bộ - tại sao, Microsoft, tại sao?!?!) được gọi là SynchronizedList of T. Tôi đang sao chép, dán mã ở đây:

   [Serializable()]
    internal class SynchronizedList : IList<T> {
        private List<T> _list;
        private Object _root;

        internal SynchronizedList(List<T> list) {
            _list = list;
            _root = ((System.Collections.ICollection)list).SyncRoot;
        }

        public int Count {
            get {
                lock (_root) { 
                    return _list.Count; 
                }
            }
        }

        public bool IsReadOnly {
            get {
                return ((ICollection<T>)_list).IsReadOnly;
            }
        }

        public void Add(T item) {
            lock (_root) { 
                _list.Add(item); 
            }
        }

        public void Clear() {
            lock (_root) { 
                _list.Clear(); 
            }
        }

        public bool Contains(T item) {
            lock (_root) { 
                return _list.Contains(item);
            }
        }

        public void CopyTo(T[] array, int arrayIndex) {
            lock (_root) { 
                _list.CopyTo(array, arrayIndex);
            }
        }

        public bool Remove(T item) {
            lock (_root) { 
                return _list.Remove(item);
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
            lock (_root) { 
                return _list.GetEnumerator();
            }
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator() {
            lock (_root) { 
                return ((IEnumerable<T>)_list).GetEnumerator();
            }
        }

        public T this[int index] {
            get {
                lock(_root) {
                    return _list[index];
                }
            }
            set {
                lock(_root) {
                    _list[index] = value;
                }
            }
        }

        public int IndexOf(T item) {
            lock (_root) {
                return _list.IndexOf(item);
            }
        }

        public void Insert(int index, T item) {
            lock (_root) {
                _list.Insert(index, item);
            }
        }

        public void RemoveAt(int index) {
            lock (_root) {
                _list.RemoveAt(index);
            }
        }
    }

Cá nhân tôi nghĩ rằng họ biết một triển khai tốt hơn bằng cách sử dụng SemaphoreSlim có thể được tạo ra, nhưng không thực hiện được.

Bạn cũng có thể sử dụng

Monitor.Enter(lock);
Monitor.Exit(lock);

khóa nào sử dụng (xem bài đăng này C # Khóa một đối tượng được chỉ định lại trong khối khóa ).

Nếu bạn đang mong đợi các ngoại lệ trong mã, điều này không an toàn nhưng nó cho phép bạn thực hiện một số việc như sau:

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

public class Something
{
    private readonly object _lock;
    private readonly List<string> _contents;

    public Something()
    {
        _lock = new object();

        _contents = new List<string>();
    }

    public Modifier StartModifying()
    {
        return new Modifier(this);
    }

    public class Modifier : IDisposable
    {
        private readonly Something _thing;

        public Modifier(Something thing)
        {
            _thing = thing;

            Monitor.Enter(Lock);
        }

        public void OneOfLotsOfDifferentOperations(string input)
        {
            DoSomethingWith(input);
        }

        private void DoSomethingWith(string input)
        {
            Contents.Add(input);
        }

        private List<string> Contents
        {
            get { return _thing._contents; }
        }

        private object Lock
        {
            get { return _thing._lock; }
        }

        public void Dispose()
        {
            Monitor.Exit(Lock);
        }
    }
}

public class Caller
{
    public void Use(Something thing)
    {
        using (var modifier = thing.StartModifying())
        {
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("B");

            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
        }
    }
}

Một trong những điều thú vị về điều này là bạn sẽ nhận được khóa trong suốt thời gian của chuỗi hoạt động (thay vì khóa trong mỗi hoạt động). Có nghĩa là đầu ra sẽ xuất hiện đúng phần (cách sử dụng của tôi về điều này là đưa một số đầu ra lên màn hình từ một quy trình bên ngoài)

Tôi thực sự thích sự đơn giản + minh bạch của ThreadSafeList + có vai trò quan trọng trong việc ngăn chặn sự cố

Trong .NET Core (bất kỳ phiên bản nào), bạn có thể sử dụng ImmutableList , có tất cả các chức năng của List<T>.

Tôi tin rằng _list.ToList()sẽ làm cho bạn một bản sao. Bạn cũng có thể truy vấn nó nếu bạn cần, chẳng hạn như:

_list.Select("query here").ToList(); 

Dù sao, msdn nói rằng đây thực sự là một bản sao và không chỉ đơn giản là một tài liệu tham khảo. Ồ, và vâng, bạn sẽ cần phải khóa phương thức thiết lập như những người khác đã chỉ ra.

Có vẻ như nhiều người tìm thấy điều này đang muốn một bộ sưu tập có kích thước động được lập chỉ mục an toàn theo chuỗi. Điều gần nhất và dễ dàng nhất mà tôi biết sẽ là.

System.Collections.Concurrent.ConcurrentDictionary<int, YourDataType>

Điều này sẽ yêu cầu bạn đảm bảo khóa của bạn được ghi đúng cách nếu bạn muốn hành vi lập chỉ mục bình thường. Nếu bạn cẩn thận, .count có thể đủ làm khóa cho bất kỳ cặp giá trị khóa mới nào bạn thêm vào.

Tôi sẽ đề nghị bất kỳ ai đang xử lý List<T>các kịch bản đa luồng nên xem xét các Bộ sưu tập bất biến, cụ thể là ImmutableArray .

Tôi thấy nó rất hữu ích khi bạn có:

1. Tương đối ít mục trong danh sách
2. Không có quá nhiều thao tác đọc / ghi
3. RẤT NHIỀU quyền truy cập đồng thời (tức là nhiều luồng truy cập danh sách ở chế độ đọc)

Cũng có thể hữu ích khi bạn cần thực hiện một số loại hành vi giống như giao dịch (tức là hoàn nguyên thao tác chèn / cập nhật / xóa trong trường hợp không thành công)

Đây là lớp học mà bạn đã yêu cầu:

namespace AI.Collections {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.Serialization;
    using System.Threading.Tasks;
    using System.Threading.Tasks.Dataflow;

    /// <summary>
    ///     Just a simple thread safe collection.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <value>Version 1.5</value>
    /// <remarks>TODO replace locks with AsyncLocks</remarks>
    [DataContract( IsReference = true )]
    public class ThreadSafeList<T> : IList<T> {
        /// <summary>
        ///     TODO replace the locks with a ReaderWriterLockSlim
        /// </summary>
        [DataMember]
        private readonly List<T> _items = new List<T>();

        public ThreadSafeList( IEnumerable<T> items = null ) { this.Add( items ); }

        public long LongCount {
            get {
                lock ( this._items ) {
                    return this._items.LongCount();
                }
            }
        }

        public IEnumerator<T> GetEnumerator() { return this.Clone().GetEnumerator(); }

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

        public void Add( T item ) {
            if ( Equals( default( T ), item ) ) {
                return;
            }
            lock ( this._items ) {
                this._items.Add( item );
            }
        }

        public Boolean TryAdd( T item ) {
            try {
                if ( Equals( default( T ), item ) ) {
                    return false;
                }
                lock ( this._items ) {
                    this._items.Add( item );
                    return true;
                }
            }
            catch ( NullReferenceException ) { }
            catch ( ObjectDisposedException ) { }
            catch ( ArgumentNullException ) { }
            catch ( ArgumentOutOfRangeException ) { }
            catch ( ArgumentException ) { }
            return false;
        }

        public void Clear() {
            lock ( this._items ) {
                this._items.Clear();
            }
        }

        public bool Contains( T item ) {
            lock ( this._items ) {
                return this._items.Contains( item );
            }
        }

        public void CopyTo( T[] array, int arrayIndex ) {
            lock ( this._items ) {
                this._items.CopyTo( array, arrayIndex );
            }
        }

        public bool Remove( T item ) {
            lock ( this._items ) {
                return this._items.Remove( item );
            }
        }

        public int Count {
            get {
                lock ( this._items ) {
                    return this._items.Count;
                }
            }
        }

        public bool IsReadOnly { get { return false; } }

        public int IndexOf( T item ) {
            lock ( this._items ) {
                return this._items.IndexOf( item );
            }
        }

        public void Insert( int index, T item ) {
            lock ( this._items ) {
                this._items.Insert( index, item );
            }
        }

        public void RemoveAt( int index ) {
            lock ( this._items ) {
                this._items.RemoveAt( index );
            }
        }

        public T this[ int index ] {
            get {
                lock ( this._items ) {
                    return this._items[ index ];
                }
            }
            set {
                lock ( this._items ) {
                    this._items[ index ] = value;
                }
            }
        }

        /// <summary>
        ///     Add in an enumerable of items.
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="asParallel"></param>
        public void Add( IEnumerable<T> collection, Boolean asParallel = true ) {
            if ( collection == null ) {
                return;
            }
            lock ( this._items ) {
                this._items.AddRange( asParallel
                                              ? collection.AsParallel().Where( arg => !Equals( default( T ), arg ) )
                                              : collection.Where( arg => !Equals( default( T ), arg ) ) );
            }
        }

        public Task AddAsync( T item ) {
            return Task.Factory.StartNew( () => { this.TryAdd( item ); } );
        }

        /// <summary>
        ///     Add in an enumerable of items.
        /// </summary>
        /// <param name="collection"></param>
        public Task AddAsync( IEnumerable<T> collection ) {
            if ( collection == null ) {
                throw new ArgumentNullException( "collection" );
            }

            var produce = new TransformBlock<T, T>( item => item, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount } );

            var consume = new ActionBlock<T>( action: async obj => await this.AddAsync( obj ), dataflowBlockOptions: new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount } );
            produce.LinkTo( consume );

            return Task.Factory.StartNew( async () => {
                collection.AsParallel().ForAll( item => produce.SendAsync( item ) );
                produce.Complete();
                await consume.Completion;
            } );
        }

        /// <summary>
        ///     Returns a new copy of all items in the <see cref="List{T}" />.
        /// </summary>
        /// <returns></returns>
        public List<T> Clone( Boolean asParallel = true ) {
            lock ( this._items ) {
                return asParallel
                               ? new List<T>( this._items.AsParallel() )
                               : new List<T>( this._items );
            }
        }

        /// <summary>
        ///     Perform the <paramref name="action" /> on each item in the list.
        /// </summary>
        /// <param name="action">
        ///     <paramref name="action" /> to perform on each item.
        /// </param>
        /// <param name="performActionOnClones">
        ///     If true, the <paramref name="action" /> will be performed on a <see cref="Clone" /> of the items.
        /// </param>
        /// <param name="asParallel">
        ///     Use the <see cref="ParallelQuery{TSource}" /> method.
        /// </param>
        /// <param name="inParallel">
        ///     Use the
        ///     <see
        ///         cref="Parallel.ForEach{TSource}(System.Collections.Generic.IEnumerable{TSource},System.Action{TSource})" />
        ///     method.
        /// </param>
        public void ForEach( Action<T> action, Boolean performActionOnClones = true, Boolean asParallel = true, Boolean inParallel = false ) {
            if ( action == null ) {
                throw new ArgumentNullException( "action" );
            }
            var wrapper = new Action<T>( obj => {
                try {
                    action( obj );
                }
                catch ( ArgumentNullException ) {
                    //if a null gets into the list then swallow an ArgumentNullException so we can continue adding
                }
            } );
            if ( performActionOnClones ) {
                var clones = this.Clone( asParallel: asParallel );
                if ( asParallel ) {
                    clones.AsParallel().ForAll( wrapper );
                }
                else if ( inParallel ) {
                    Parallel.ForEach( clones, wrapper );
                }
                else {
                    clones.ForEach( wrapper );
                }
            }
            else {
                lock ( this._items ) {
                    if ( asParallel ) {
                        this._items.AsParallel().ForAll( wrapper );
                    }
                    else if ( inParallel ) {
                        Parallel.ForEach( this._items, wrapper );
                    }
                    else {
                        this._items.ForEach( wrapper );
                    }
                }
            }
        }

        /// <summary>
        ///     Perform the <paramref name="action" /> on each item in the list.
        /// </summary>
        /// <param name="action">
        ///     <paramref name="action" /> to perform on each item.
        /// </param>
        /// <param name="performActionOnClones">
        ///     If true, the <paramref name="action" /> will be performed on a <see cref="Clone" /> of the items.
        /// </param>
        /// <param name="asParallel">
        ///     Use the <see cref="ParallelQuery{TSource}" /> method.
        /// </param>
        /// <param name="inParallel">
        ///     Use the
        ///     <see
        ///         cref="Parallel.ForEach{TSource}(System.Collections.Generic.IEnumerable{TSource},System.Action{TSource})" />
        ///     method.
        /// </param>
        public void ForAll( Action<T> action, Boolean performActionOnClones = true, Boolean asParallel = true, Boolean inParallel = false ) {
            if ( action == null ) {
                throw new ArgumentNullException( "action" );
            }
            var wrapper = new Action<T>( obj => {
                try {
                    action( obj );
                }
                catch ( ArgumentNullException ) {
                    //if a null gets into the list then swallow an ArgumentNullException so we can continue adding
                }
            } );
            if ( performActionOnClones ) {
                var clones = this.Clone( asParallel: asParallel );
                if ( asParallel ) {
                    clones.AsParallel().ForAll( wrapper );
                }
                else if ( inParallel ) {
                    Parallel.ForEach( clones, wrapper );
                }
                else {
                    clones.ForEach( wrapper );
                }
            }
            else {
                lock ( this._items ) {
                    if ( asParallel ) {
                        this._items.AsParallel().ForAll( wrapper );
                    }
                    else if ( inParallel ) {
                        Parallel.ForEach( this._items, wrapper );
                    }
                    else {
                        this._items.ForEach( wrapper );
                    }
                }
            }
        }
    }
}

Về cơ bản, nếu bạn muốn liệt kê một cách an toàn, bạn cần phải sử dụng khóa.

Vui lòng tham khảo MSDN về điều này. http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

Đây là một phần của MSDN mà bạn có thể quan tâm:

Các thành viên tĩnh công cộng (Được chia sẻ trong Visual Basic) của loại này là an toàn luồng. Bất kỳ thành viên cá thể nào đều không được đảm bảo an toàn cho chuỗi.

Một Danh sách có thể hỗ trợ đồng thời nhiều người đọc, miễn là bộ sưu tập không bị sửa đổi. Việc liệt kê thông qua một bộ sưu tập về bản chất không phải là một thủ tục an toàn theo chuỗi. Trong trường hợp hiếm hoi khi một phép liệt kê có một hoặc nhiều quyền truy cập ghi, cách duy nhất để đảm bảo an toàn luồng là khóa bộ sưu tập trong toàn bộ phép liệt kê. Để cho phép bộ sưu tập được nhiều luồng truy cập để đọc và ghi, bạn phải triển khai đồng bộ hóa của riêng mình.

Đây là lớp cho danh sách an toàn luồng không có khóa

 public class ConcurrentList   
    {
        private long _i = 1;
        private ConcurrentDictionary<long, T> dict = new ConcurrentDictionary<long, T>();  
        public int Count()
        {
            return dict.Count;
        }
         public List<T> ToList()
         {
            return dict.Values.ToList();
         }

        public T this[int i]
        {
            get
            {
                long ii = dict.Keys.ToArray()[i];
                return dict[ii];
            }
        }
        public void Remove(T item)
        {
            T ov;
            var dicItem = dict.Where(c => c.Value.Equals(item)).FirstOrDefault();
            if (dicItem.Key > 0)
            {
                dict.TryRemove(dicItem.Key, out ov);
            }
            this.CheckReset();
        }
        public void RemoveAt(int i)
        {
            long v = dict.Keys.ToArray()[i];
            T ov;
            dict.TryRemove(v, out ov);
            this.CheckReset();
        }
        public void Add(T item)
        {
            dict.TryAdd(_i, item);
            _i++;
        }
        public IEnumerable<T> Where(Func<T, bool> p)
        {
            return dict.Values.Where(p);
        }
        public T FirstOrDefault(Func<T, bool> p)
        {
            return dict.Values.Where(p).FirstOrDefault();
        }
        public bool Any(Func<T, bool> p)
        {
            return dict.Values.Where(p).Count() > 0 ? true : false;
        }
        public void Clear()
        {
            dict.Clear();
        }
        private void CheckReset()
        {
            if (dict.Count == 0)
            {
                this.Reset();
            }
        }
        private void Reset()
        {
            _i = 1;
        }
    }

Sử dụng lockcâu lệnh để làm điều này. ( Đọc ở đây để biết thêm thông tin. )

private List<T> _list;

private List<T> MyT
{
    get { return _list; }
    set
    {
        //Lock so only one thread can change the value at any given time.
        lock (_list)
        {
            _list = value;
        }
    }
}

FYI đây có thể không phải là chính xác những gì bạn yêu cầu - bạn có thể muốn khóa mã của mình xa hơn nhưng tôi không thể cho rằng điều đó. Hãy xem xét locktừ khóa và điều chỉnh việc sử dụng nó cho phù hợp với tình huống cụ thể của bạn.

Nếu bạn cần, bạn có thể locktrong cả khối getvà setbằng cách sử dụng _listbiến để biến nó không thể xảy ra đọc / ghi cùng một lúc.