Cách chia sẻ dữ liệu giữa các luồng khác nhau Trong C# bằng AOP?

Question

Cách chia sẻ dữ liệu giữa các luồng khác nhau Trong C# mà không sử dụng các biến tĩnh? Chúng ta có thể tạo ra một máy móc như vậy bằng cách sử dụng thuộc tính?

Trợ giúp lập trình hướng Aspect trong các trường hợp như vậy?

Để đạt được điều này, tất cả các luồng khác nhau sẽ hoạt động trên một đối tượng?

Answer 1

Bạn có thể chuyển đối tượng làm đối số cho Thread.Start và sử dụng nó làm bộ nhớ dữ liệu được chia sẻ giữa chuỗi hiện tại và chuỗi khởi tạo.

Bạn cũng có thể truy cập trực tiếp (với khóa khóa thích hợp của khóa học) các thành viên dữ liệu của bạn, nếu bạn bắt đầu chuỗi bằng cách sử dụng biểu mẫu của đại biểu ThreadStart.

Bạn không thể sử dụng thuộc tính để tạo dữ liệu được chia sẻ giữa các chuỗi. Bạn có thể sử dụng các cá thể thuộc tính được gắn vào lớp của bạn như là một lưu trữ dữ liệu, nhưng tôi không thấy cách nó tốt hơn sử dụng các thành viên dữ liệu tĩnh hoặc cá thể.

Answer 2

Bạn không thể đánh bại sự đơn giản của hàng đợi tin nhắn bị khóa. Tôi nói đừng lãng phí thời gian của bạn với bất cứ điều gì phức tạp hơn.

Đọc trên báo cáo khóa.

lock

EDIT

Dưới đây là một ví dụ của đối tượng Microsoft Queue bọc vì vậy tất cả các hành động chống lại nó là chủ đề an toàn.

public class Queue<T> 
{ 
    /// <summary>Used as a lock target to ensure thread safety.</summary> 
    private readonly Locker _Locker = new Locker(); 

    private readonly System.Collections.Generic.Queue<T> _Queue = new System.Collections.Generic.Queue<T>(); 

    /// <summary></summary> 
    public void Enqueue(T item) 
    { 
     lock (_Locker) 
     { 
      _Queue.Enqueue(item); 
     } 
    } 

    /// <summary>Enqueues a collection of items into this queue.</summary> 
    public virtual void EnqueueRange(IEnumerable<T> items) 
    { 
     lock (_Locker) 
     { 
      if (items == null) 
      { 
       return; 
      } 

      foreach (T item in items) 
      { 
       _Queue.Enqueue(item); 
      } 
     } 
    } 

    /// <summary></summary> 
    public T Dequeue() 
    { 
     lock (_Locker) 
     { 
      return _Queue.Dequeue(); 
     } 
    } 

    /// <summary></summary> 
    public void Clear() 
    { 
     lock (_Locker) 
     { 
      _Queue.Clear(); 
     } 
    } 

    /// <summary></summary> 
    public Int32 Count 
    { 
     get 
     { 
      lock (_Locker) 
      { 
       return _Queue.Count; 
      } 
     } 
    } 

    /// <summary></summary> 
    public Boolean TryDequeue(out T item) 
    { 
     lock (_Locker) 
     { 
      if (_Queue.Count > 0) 
      { 
       item = _Queue.Dequeue(); 
       return true; 
      } 
      else 
      { 
       item = default(T); 
       return false; 
      } 
     } 
    } 
} 

EDIT 2

Tôi hy vọng ví dụ này giúp. Hãy nhớ rằng đây là xương trần. Sử dụng những ý tưởng cơ bản này, bạn có thể khai thác sức mạnh của chủ đề một cách an toàn.

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

Answer 3

Khi bạn bắt đầu một chuỗi bạn đang thực hiện một phương pháp của một số lớp đã chọn. Tất cả các thuộc tính của lớp đó được hiển thị.

Worker myWorker = new Worker(/* arguments */); 

    Thread myThread = new Thread(new ThreadStart(myWorker.doWork)); 

    myThread.Start(); 

Chuỗi của bạn hiện đang ở phương thức doWork() và có thể thấy bất kỳ thuộc tính nào của myWorker, có thể là các đối tượng khác. Bây giờ bạn chỉ cần cẩn thận để đối phó với các trường hợp có một số chủ đề tất cả nhấn các thuộc tính cùng một lúc.

Answer 4

Nhìn vào mã ví dụ sau:

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

Trong trường hợp này, các lớp chủ đề MyWorker có một biến state. Chúng tôi khởi tạo nó với đối tượng cùng một đối tượng. Bây giờ bạn có thể thấy rằng hai công nhân truy cập vào cùng một đối tượng SharedData. Thay đổi được thực hiện bởi một công nhân được hiển thị cho người khác.

Bạn có một số vấn đề còn lại.Nhân viên 2 biết khi nào các thay đổi đã được thực hiện bởi nhân viên 1 và ngược lại? Làm thế nào để bạn ngăn chặn các thay đổi xung đột? Có thể đọc: this tutorial.