C# 中忙于等待

Question

How do you implement busy waiting in a not total inefficient way? I am facing the issue that I can load the data of my model only in a pull manner, which means I have to invoke getXYZ() methods in a continuous way.

This has to happen not fast enough for user interaction, but fast enought, that when a state in the GUI is changed, the model can be noticed and the new state is received by the getXYZ() methods.

My approach simply be:

while (c.hasChanged()) {
   Thread.sleep(500);
}
updateData();

Are there better mechanisms?

Answer 1

Your problem seems to be solvable with Threading .

In WPF you can do:

Thread t = new Thread((ThreadStart)delegate() {
   while (true) {
      Thread.sleep(500);
      if (c.hasChanged())
          Dispatcher.Invoke((Action)delegate() {updateData();});
   }

}).Start();

In WinForms

Thread t = new Thread((ThreadStart)delegate() {
   while (true) {
      Thread.sleep(500);
      // this must derive from Control
      if (c.hasChanged())
          this.Invoke((Action)delegate() {updateData();});
   }

}).Start();

There may be missing parameters to Invoke (which is needed to execute the code on the calling UI thread) but I'm writing this from my brain so no intellisense at disposal:D

In .NET 4 you can use TaskFactory.StartNew instead of spawning a thread by yourself. In.Net <= 4, you could use the TreadPool for the thread. However I recall you need this to be run at once because you expect it to be there checking as soon as possible and the thread pool won't assure you that (it could be already full, but not very likely:-). Just don't do silly things like spawning more of them in a loop!

And inside the thread you should put a check like

while (!Closing)

so that the thread can finish when you need it without having to resort to bad things like t.Abort(); An when exiting put the Closing to true and do a t.Join() to close the checker thread.

EDIT:

I forgot to say that the Closing should be a bool property or a VOLATILE boolean, not a simple boolean, because you won't be ensured that the thread could ever finish (well it would in case you are closing the application, but it is good practice to make them finish by your will). the volatile keyword is intended to prevent the (pseudo)compiler from applying any optimizations on the code that assume values of variables cannot change

Answer 2

It's not clear from your post exactly what you are trying to do, but it sounds like you should put your model/service calls on a separate thread (via Background worker or async delegate) and use a callback from the model/service call to notify the UI when it's done. Your UI thread can then do busy things, like show a progress bar, but not become unresponsive.

Answer 3

If you are polling from a GUI, use a (WinForms) Timer.

If this is some kind of background process, your Sleep() may be the lesser evil.

Answer 4

Explicit busy waiting is evil and must be avoided whenever possible.

If you cannot avoid it, then build your application using the Observer design pattern and register the interested objects to an object which performs the polling, backed by a thread.

That way you have a clean design, confining the ugly stuff in just one place.