将数据传递给正在运行的线程的正确方法是什么

Question

在大多数情况下，当您创建线程时，您可以预先准备数据并将其传递到构造函数或方法中。

然而，在像打开套接字连接这样的情况下，您通常已经创建了一个线程，但希望告诉它执行某些操作。

基本思想：

C#

private Thread _MyThread = new Thread(MyMethod);
this._MyThread.Start(param);   

Java

private Thread _MyThread = new Thread(new MyRunnableClass(param));
this._MyThread.start();

Now what?

那么在 C# 和 Java 中将数据传递给正在运行的线程的正确方法是什么？

Answer 1

将数据传递到正在运行的线程的一种方法是实现消息队列。想要告诉侦听线程执行某些操作的线程会将一个项目添加到侦听线程的队列中。侦听线程以阻塞方式从此线程读取。当没有要执行的操作时使其等待。每当另一个线程将消息放入队列中时，它都会获取该消息，具体取决于项目及其内容，然后您可以对其执行某些操作。

这是一些 Java/伪代码：

class Listener
{
   private Queue queue;
   public SendMessage(Message m)
   {
     // This will be executed in the calling thread.
     // The locking will be done either in this function or in the Add below
     // depending on your Queue implementation.
     synchronize(this.queue) 
     {
        this.queue.put(m);
     }
   }

   public Loop()
   {
     // This function should be called from the Listener thread.
     while(true) 
     {
        Message m = this.queue.take();
        doAction(m);
     }
   }

   public doAction(Message m)
   {
      if (m is StopMessage)
      {
        ...
      }
   }
}

调用者：

class Caller
{
  private Listener listener;

  LetItStop()
  {
     listener.SendMessage(new StopMessage());
  }
}

当然，在编写并行/并发代码时有很多最佳实践。例如，您至少应该添加一个类似于 run :: Bool 的字段，而不是 while(true) ，您可以在收到 StopMessage 时将其设置为 false。根据您想要实现此功能的语言，您将需要处理其他原语和行为。

例如，在 Java 中，您可能需要使用 java.util.Concurrent 包让事情变得简单。

Answer 2

Java

你基本上可以有一个LinkedList（一个LIFO< /a>）并继续（进行某些操作）如下（未经测试）：

 class MyRunnable<T> implements Runnable {
     private LinkedList<T> queue;
     private boolean stopped;
     public MyRunnable(LinkedList<T> queue) { 
         this.queue = queue; 
         this.stopped = false; 
     }
     public void stopRunning() {
         stopped = true;
         synchronized (queue) {
             queue.notifyAll();
         }
     }
     public void run() {
         T current;
         while (!stopped) {
             synchronized (queue) {
                 queue.wait();
             }
             if (queue.isEmpty()) {
                 try { Thread.sleep(1); } catch (InterruptedException e) {}
             } else {
                 current = queue.removeFirst();

                 // do something with the data from the queue

             }
             Thread.yield();
         }
     }
 }

当您在其他地方保留对参数中给出的 LinkedList 实例的引用时，您所要做的就是：

 synchronized (queue) {
    queue.addLast(T);  // add your T element here. You could even handle some
                       // sort of priority queue by adding at a given index
    queue.notifyAll();
 }

Answer 3

编辑：误读问题，

C#
我通常做的是创建一个全局静态类，然后在那里设置值。这样您就可以从两个线程访问它。不确定这是否是首选方法，并且可能存在应该处理的锁定发生的情况（如果我错了，请纠正我）。

我还没有尝试过，但它也应该适用于线程池/后台工作者。

Answer 4

我能想到的一种方法是通过属性文件。

Answer 5

嗯，这在很大程度上取决于线程应该完成的工作。
例如，您可以有一个等待事件（例如ManualResetEvent）的线程和一个放置工作项（可以是要处理的数据结构，或者遵循命令模式的更聪明的命令）的共享队列。有人将新工作添加到队列并发出事件信号，因此 trhread 被唤醒，从队列中获取工作并开始执行其任务。

您可以将此代码封装在自定义队列中，其中调用 Deque 方法的任何线程都会停止，直到有人调用 Add(item)。

另一方面，也许您想依赖 .NET ThreadPool 类来发出任务以由池中的线程执行。

这个例子有一点帮助吗？

Answer 6

您可以使用委托模式，其中子线程订阅事件，主线程引发事件并传递参数。

Answer 7

您可以在循环中运行工作线程（如果这对您的要求有意义），并在每次执行循环时检查标志。该标志将由另一个线程设置，以向工作线程发出某些状态已更改的信号，它也可以同时设置一个字段来传递新状态。

此外，您可以使用monitor.wait和monitor.pulse来指示线程之间的状态变化。

显然，上面需要同步。