c#: what is a thread polling?

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

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.

Here you go: check out this website:

http://msdn.microsoft.com/en-us/library/dsw9f9ts%28VS.71%29.aspx

Synchronization Techniques

There are two approaches to synchronization, polling and using synchronization objects. Polling repeatedly checks the status of an asynchronous call from within a loop. Polling is the least efficient way to manage threads because it wastes resources by repeatedly checking the status of the various thread properties.

For example, the IsAlive property can be used when polling to see if a thread has exited. Use this property with caution because a thread that is alive is not necessarily running. You can use the thread's ThreadState property to get more detailed information about a thread's status. Because threads can be in more than one state at any given time, the value stored in ThreadState can be a combination of the values in the System.Threading.Threadstate enumeration. Consequently, you should carefully check all relevant thread states when polling. For example, if a thread's state indicates that it is not Running, it may be done. On the other hand, it may be suspended or sleeping. Waiting for a Thread to Finish

The Thread.Join method is useful for determining if a thread has completed before starting another task. The Join method waits a specified amount of time for a thread to end. If the thread ends before the timeout, Join returns True; otherwise it returns False. For information on Join, see Thread.Join Method

Polling sacrifices many of the advantages of multithreading in return for control over the order that threads run. Because it is so inefficient, polling generally not recommended. A more efficient approach would use the Join method to control threads. Join causes a calling procedure to wait either until a thread is done or until the call times out if a timeout is specified. The name, join, is based on the idea that creating a new thread is a fork in the execution path. You use Join to merge separate execution paths into a single thread again

One point should be clear: Join is a synchronous or blocking call. Once you call Join or a wait method of a wait handle, the calling procedure stops and waits for the thread to signal that it is done. Copy

Sub JoinThreads()
   Dim Thread1 As New System.Threading.Thread(AddressOf SomeTask)
   Thread1.Start()
   Thread1.Join()      ' Wait for the thread to finish.
   MsgBox("Thread is done")
End Sub

These simple ways of controlling threads, which are useful when you are managing a small number of threads, are difficult to use with large projects. The next section discusses some advanced techniques you can use to synchronize threads.

Hope this helps.

PK

Polling can be used in reference to the four asyncronous patterns .NET uses for delegate execution.

The 4 types (I've taken these descriptions from this well explained answer) are:

1. Polling: waiting in a loop for IAsyncResult.Completed to be true
2. I'll call you
3. You call me
4. I don't care what happens (fire and forget)

So for an example of 1:

Action<IAsyncResult> myAction = (IAsyncResult ar) =>
{
    // Send Nigerian Prince emails
    Console.WriteLine("Starting task");
    Thread.Sleep(2000);

    // Finished
    Console.WriteLine("Finished task");

};

IAsyncResult result = myAction.BeginInvoke(null,null,null);
while (!result.IsCompleted)
{
    // Do something while you wait
    Console.WriteLine("I'm waiting...");
}

There's alternative ways of polling, but in general it means "I we there yet", "I we there yet", "I we there yet"

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.

I would have to see the context in which this statement was made to express an opinion on it either way. However, taken as-is it is patently false. Polling is a very common and very accepted strategy for signaling threads.

Pretty much all lock-free thread signaling strategies use polling in some form or another. This is clearly evident in how these strategies typically spin around in a loop until a certain condition is met.

The most frequently used scenario is the case of signaling a worker thread that it is time to terminate. The worker thread will periodically poll a bool flag at safe points to see if a shutdown was requested.

private volatile bool shutdownRequested;

void WorkerThread()
{
  while (true)
  {
    // Do some work here.

    // This is a safe point so see if a shutdown was requested.
    if (shutdownRequested) break;

   // Do some more work here.
  }
}