Question

What does it mean when one says no polling is allowed when implimenting your thread solution since it’s wasteful, it has latency and it’s non-deterministic. Threads should not use polling to signal each other.

EDIT

Based on your answers so far, I believe my threading implementation (taken from: http://www.albahari.com/threading/part2.aspx#_AutoResetEvent) below is not using polling. Please correct me if I am wrong.

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

class ProducerConsumerQueue : IDisposable {
  EventWaitHandle _wh = new AutoResetEvent (false);
  Thread _worker;
  readonly object _locker = new object();
  Queue<string> _tasks = new Queue<string>();

  public ProducerConsumerQueue() (
    _worker = new Thread (Work);
    _worker.Start();
  }

  public void EnqueueTask (string task) (
    lock (_locker) _tasks.Enqueue (task);
    _wh.Set();
  }

  public void Dispose() (
    EnqueueTask (null);     // Signal the consumer to exit.
    _worker.Join();         // Wait for the consumer's thread to finish.
    _wh.Close();            // Release any OS resources.
  }

  void Work() (
    while (true)
    {
      string task = null;
      lock (_locker)
        if (_tasks.Count > 0)
        {
          task = _tasks.Dequeue();
          if (task == null) return;
        }
      if (task != null)
      {
        Console.WriteLine ("Performing task: " + task);
        Thread.Sleep (1000);  // simulate work...
      }
      else
        _wh.WaitOne();         // No more tasks - wait for a signal
    }
  }
}

Answer 1

Your question is very unclear, but typically “polling” refers to periodically checking for a condition, or sampling a value. For example:

while (true)
{
    Task task = GetNextTask();
    if (task != null)
    {
         task.Execute();
    }
    else
    {
         Thread.Sleep(5000); // Avoid tight-looping
    }
}

Just sleeping is a relatively inefficient way of doing this – it’s better if there’s some coordination so that the thread can wake up immediately when something interesting happens, e.g. via Monitor.Wait/Pulse or Manual/AutoResetEvent… but depending on the context, that’s not always possible.

In some contexts you may not want the thread to actually sleep – you may want it to become available for other work. For example, you might use a Timer of one sort or other to periodically poll a mailbox to see whether there’s any incoming mail – but you don’t need the thread to actually be sleeping when it’s not checking; it can be reused by another thread-pool task.