Come condividere i dati tra diversi thread In C # utilizzando AOP?

Come condividere i dati tra diversi thread In C # senza utilizzare le variabili statiche? Possiamo creare un tale machanism usando l’attributo?

In questi casi la programmazione orientata all’aspetto può essere d’aiuto?

Per raggiungere questo tutti i diversi thread dovrebbero funzionare su un singolo object?

È ansible passare un object come argomento a Thread.Start e utilizzarlo come archivio di dati condiviso tra il thread corrente e il thread di avvio.

Puoi anche accedere direttamente (con il blocco appropriato, ovviamente) ai tuoi membri dei dati, se hai iniziato il thread usando il modulo di istanza del delegato ThreadStart .

Non è ansible utilizzare gli attributi per creare dati condivisi tra thread. È ansible utilizzare le istanze di attributo allegate alla class come memoria di dati, ma non riesco a vedere come sia meglio dell’utilizzo di membri statici o di dati di istanza.

Non è ansible battere la semplicità di una coda di messaggi bloccata. Dico, non sprecare il tuo tempo con qualcosa di più complesso.

Leggi sulla dichiarazione di blocco .

serratura

MODIFICARE

Ecco un esempio di object Microsoft Queue avvolto in modo che tutte le azioni contro di esso siano thread-safe.

 public class Queue { /// Used as a lock target to ensure thread safety. private readonly Locker _Locker = new Locker(); private readonly System.Collections.Generic.Queue _Queue = new System.Collections.Generic.Queue(); ///  public void Enqueue(T item) { lock (_Locker) { _Queue.Enqueue(item); } } /// Enqueues a collection of items into this queue. public virtual void EnqueueRange(IEnumerable items) { lock (_Locker) { if (items == null) { return; } foreach (T item in items) { _Queue.Enqueue(item); } } } ///  public T Dequeue() { lock (_Locker) { return _Queue.Dequeue(); } } ///  public void Clear() { lock (_Locker) { _Queue.Clear(); } } ///  public Int32 Count { get { lock (_Locker) { return _Queue.Count; } } } ///  public Boolean TryDequeue(out T item) { lock (_Locker) { if (_Queue.Count > 0) { item = _Queue.Dequeue(); return true; } else { item = default(T); return false; } } } } 

MODIFICA 2

Spero che questo esempio aiuti. Ricorda che questo è ossa nude. Usando queste idee di base puoi sfruttare in tutta sicurezza la potenza dei thread.

 public class WorkState { private readonly Object _Lock = new Object(); private Int32 _State; public Int32 GetState() { lock (_Lock) { return _State; } } public void UpdateState() { lock (_Lock) { _State++; } } } public class Worker { private readonly WorkState _State; private readonly Thread _Thread; private volatile Boolean _KeepWorking; public Worker(WorkState state) { _State = state; _Thread = new Thread(DoWork); _KeepWorking = true; } public void DoWork() { while (_KeepWorking) { _State.UpdateState(); } } public void StartWorking() { _Thread.Start(); } public void StopWorking() { _KeepWorking = false; } } private void Execute() { WorkState state = new WorkState(); Worker worker = new Worker(state); worker.StartWorking(); while (true) { if (state.GetState() > 100) { worker.StopWorking(); break; } } } 

Guarda il seguente codice di esempio:

 public class MyWorker { public SharedData state; public void DoWork(SharedData someData) { this.state = someData; while (true) ; } } public class SharedData { X myX; public getX() { etc public setX(anX) { etc } public class Program { public static void Main() { SharedData data = new SharedDate() MyWorker work1 = new MyWorker(data); MyWorker work2 = new MyWorker(data); Thread thread = new Thread(new ThreadStart(work1.DoWork)); thread.Start(); Thread thread2 = new Thread(new ThreadStart(work2.DoWork)); thread2.Start(); } } 

In questo caso, la class Thread MyWorker ha uno state variabile. Inizializziamo con lo stesso object. Ora puoi vedere che i due lavoratori accedono allo stesso object SharedData. Le modifiche apportate da un lavoratore sono visibili all’altro.

Hai ancora alcuni problemi rimanenti. In che modo worker 2 sa quando sono state apportate modifiche da worker 1 e viceversa? Come prevedi modifiche in conflitto? Forse leggi: questo tutorial .

Quando inizi una discussione stai eseguendo un metodo di una class scelta. Tutti gli attributi di quella class sono visibili.

  Worker myWorker = new Worker( /* arguments */ ); Thread myThread = new Thread(new ThreadStart(myWorker.doWork)); myThread.Start(); 

La tua discussione è ora nel metodo doWork () e può vedere qualsiasi atrributes di myWorker, che possono essere essi stessi altri oggetti. Ora devi solo stare attento ad affrontare i casi in cui diversi thread hanno colpito tutti quegli attributi nello stesso momento.