Proprietà List <T> thread-safe

Voglio un'implementazione di List<T> come una proprietà che può essere utilizzata in modo sicuro senza alcun dubbio.

Qualcosa come questo:

private List<T> _list;

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

Sembra che sia ancora necessario restituire una copia (clonata) della raccolta quindi se da qualche parte stiamo iterando la raccolta e allo stesso tempo la raccolta è impostata, non viene sollevata alcuna eccezione.

Come implementare una proprietà di raccolta thread-safe?

Se stai prendendo di mira .Net 4 ci sono alcune opzioni in System.Collections.Concurrent Namespace

Potresti usare ConcurrentBag<T>in questo caso invece diList<T>

Anche se ha ottenuto il maggior numero di voti, di solito non si può prendere System.Collections.Concurrent.ConcurrentBag<T>come sostituto thread-safe per System.Collections.Generic.List<T>ciò che è (Radek Stromský lo ha già fatto notare) non ordinato.

Ma c'è una classe chiamata System.Collections.Generic.SynchronizedCollection<T> che è già da .NET 3.0 parte del framework, ma è così ben nascosta in una posizione in cui non ci si aspetta che sia poco conosciuta e probabilmente non ci si è mai imbattuti in essa (almeno Non l'ho mai fatto).

SynchronizedCollection<T>viene compilato nell'assembly System.ServiceModel.dll (che fa parte del profilo client ma non della libreria di classi portabile).

Spero che aiuti.

Penso che creare una classe ThreadSafeList di esempio sarebbe facile:

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

È sufficiente clonare l'elenco prima di richiedere un enumeratore e quindi qualsiasi enumerazione funziona su una copia che non può essere modificata durante l'esecuzione.

Anche la risposta accettata è ConcurrentBag, non credo che sia una vera sostituzione di list in tutti i casi, come dice il commento di Radek alla risposta: "ConcurrentBag è una raccolta non ordinata, quindi a differenza di List non garantisce l'ordinazione. Inoltre non è possibile accedere agli elementi per indice ".

Pertanto, se si utilizza .NET 4.0 o versioni successive, una soluzione alternativa potrebbe essere quella di utilizzare ConcurrentDictionary con il numero intero TKey come indice di matrice e TValue come valore di matrice. Questo è il modo consigliato per sostituire l'elenco nel corso C # Raccolte simultanee di Pluralsight . ConcurrentDictionary risolve entrambi i problemi sopra menzionati: accesso all'indice e ordinamento (non possiamo fare affidamento sull'ordinamento poiché è una tabella hash sotto il cofano, ma l'attuale implementazione .NET salva l'ordine degli elementi aggiunti).

La ArrayListclasse di C # ha un Synchronizedmetodo.

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

Ciò restituisce un wrapper thread-safe attorno a qualsiasi istanza di IList. Tutte le operazioni devono essere eseguite tramite il wrapper per garantire la sicurezza del filo.

Se guardi il codice sorgente di List of T ( https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,c66df6f36c131877 ) noterai che c'è una classe lì (che ovviamente è interno - perché, Microsoft, perché?!?!) chiamato SynchronizedList of T. Sto copiando incollando il codice qui:

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

Personalmente penso che sapessero che sarebbe stata possibile creare un'implementazione migliore utilizzando SemaphoreSlim , ma non ci sono riuscita.

Puoi anche usare il più primitivo

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

quale blocco utilizza (vedere questo articolo Blocco in C # di un oggetto riassegnato in blocco blocco ).

Se ti aspetti eccezioni nel codice, questo non è sicuro ma ti consente di fare qualcosa come il seguente:

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

Una delle cose belle di questo è che otterrai il blocco per la durata della serie di operazioni (anziché il blocco in ogni operazione). Il che significa che l'output dovrebbe uscire nei blocchi giusti (il mio utilizzo di questo era ottenere un output sullo schermo da un processo esterno)

Mi piace molto la semplicità + la trasparenza di ThreadSafeList + che fa la parte importante per fermare i crash

In .NET Core (qualsiasi versione), puoi usare ImmutableList , che ha tutte le funzionalità di List<T>.

Credo _list.ToList()che te ne farò una copia. Puoi anche interrogarlo se hai bisogno di come:

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

Ad ogni modo, msdn dice che questa è davvero una copia e non semplicemente un riferimento. Oh, e sì, dovrai bloccare il metodo set come hanno sottolineato gli altri.

Sembra che molte delle persone che lo trovano desiderino una raccolta di dimensioni dinamicamente indicizzate per thread safe. La cosa più vicina e più semplice che io sappia sarebbe.

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

Ciò richiederebbe di assicurarsi che la chiave sia correttamente incriminata se si desidera un normale comportamento di indicizzazione. Se stai attento, .count potrebbe essere sufficiente come chiave per qualsiasi nuova coppia di valori chiave che aggiungi.

Suggerirei a chiunque abbia a che fare con List<T>scenari multi-threading di dare un'occhiata alle raccolte immutabili in particolare all'ImmutableArray .

L'ho trovato molto utile quando hai:

1. Relativamente pochi elementi nell'elenco
2. Non così tante operazioni di lettura / scrittura
3. MOLTI accessi simultanei (cioè molti thread che accedono alla lista in modalità di lettura)

Può anche essere utile quando è necessario implementare una sorta di comportamento simile a una transazione (cioè annullare un'operazione di inserimento / aggiornamento / eliminazione in caso di errore)

Ecco il corso che hai chiesto:

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

Fondamentalmente, se vuoi enumerare in modo sicuro, devi usare lock.

Fare riferimento a MSDN su questo. http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

Ecco una parte di MSDN che potrebbe interessarti:

I membri statici pubblici (condivisi in Visual Basic) di questo tipo sono thread-safe. Non è garantito che tutti i membri dell'istanza siano thread-safe.

Un elenco può supportare più lettori contemporaneamente, a condizione che la raccolta non venga modificata. L'enumerazione tramite una raccolta non è intrinsecamente una procedura thread-safe. Nel raro caso in cui un'enumerazione contenga uno o più accessi in scrittura, l'unico modo per garantire la sicurezza del thread è bloccare la raccolta durante l'intera enumerazione. Per consentire l'accesso alla raccolta da più thread per la lettura e la scrittura, è necessario implementare la propria sincronizzazione.

Ecco la classe per l'elenco thread-safe senza blocco

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

Usa l' lockistruzione per farlo. ( Leggi qui per maggiori informazioni. )

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

Cordiali saluti, questo probabilmente non è esattamente ciò che stai chiedendo: probabilmente vorrai bloccare più a fondo il tuo codice, ma non posso presumerlo. Dai un'occhiata alla lockparola chiave e personalizzane l'uso in base alla tua situazione specifica.

Se è necessario, si potrebbe locksia in gete setblocco utilizzando la _listvariabile che renderebbe così una lettura / scrittura non può avvenire allo stesso tempo.