Is using multiple 'while()' loops bad practice?

Question

I am writing two applications that work with each other. One is in c++, the other in C#. As there is streaming data involved, I am using, in multiple places, code such as:

while (true)
{
 //copy streamed data to other places

}

I am noticing that these programmes use a lot of cpu, and become slow to respond. Is it bad programming to use this kind of loop? Should I be adding a:

Sleep(5);

In each one? Will that help with cpu usage?

Thanks!

You need to provide a concrete example of what you do inside that loop (and no, Sleep(5) almost never would be a good solution anyway). — Evk, May 16 '16 at 14:46
I am really just asking generally, as I am self taught, and am prone to bad practice! Is this kind of loop acceptable to just run full throttle like that? Or should I be pausing/sleeping in these loops ? — anti, May 16 '16 at 14:48
@anti this is perfectly fine to use, you'll also see some people using the equivalent `for( ; ;)` often — Alfie Goodacre, May 16 '16 at 14:49
@BartvanNierop I'd say it's only "not bad" if your machine is running a single process. Otherwise you are eating up finite resources just by busy-waiting. — TartanLlama, May 16 '16 at 14:49
while loops are not necessarily bad practice.. its what you put in them that can make them such — BugFinder, May 16 '16 at 14:51
If there is work to do, do it. If you are waiting to receive work, don't busy-wait. (And preferably don't poll either, use a wait function that is woken up by arrival of the new data) — Ben Voigt, May 16 '16 at 14:52
If adding `Sleep(5)` does anything to the CPU usage of your program, then you are doing something very wrong somewhere... — Jesper Juhl, May 16 '16 at 15:00
You should look into async, you could offload those loops into separate thread to avoid response issues. — Greg, May 16 '16 at 15:22
The general solution to this sort of problem is to wait for arrival of data and process it as it arrives (possibly caching newly arrived data as you're processing previously arrived data). As to the mechanics of the implementation - well, that depends on a concrete example. For example, often in a graphics processing application (games, for instance), the "game loop" is essentially what you describe (without sleeps). This is also encountered in GUI app design. For a design where the app waits for an event before processing, look to typical network client-server design. — , May 16 '16 at 15:29
Thanks all. I will look into Data Received events, and check through what i have in these loops. — anti, May 16 '16 at 15:41

score 5 · Answer 1 · answered May 16 '16 at 15:20

5

Generally, using Thread.Sleep() in the code will also freeze the thread so if what you worry about is responsiveness you shouldn't use it. You should consider moving the streaming methods out of the main (UI) thread

Also, you mentioned that it is some streaming process, so the best practise wouldn't be something like

while(!stream.EndOfStream)
{
//streaming
}

but rather using some DataReceived events (if available)

answered May 16 '16 at 15:20

Peuczynski

4,591
1
19
33

Thank you, I will look into this. – anti May 16 '16 at 15:39

score 2 · Answer 2 · answered May 16 '16 at 15:10

you will probably find that the code is more of the format

while (true)
{
   //WAIT for streamed data to arrive
   //READ data from stream
   //COPY streamed data to other places

   //BREAK when no more data/program is ending


}

which is totally normal. the other common solution is

while (boolean_variable_if_program_is_to_keep_running)
{
   //WAIT for streamed data to arrive
   //READ data from stream
   //COPY streamed data to other places

   //when no more data/program is ending
   //   set boolean_variable_if_program_is_to_keep_running = FALSE


}

Charly · Answer 3 · 2016-05-16T16:13:06.567

What you really need to avoid (for the health of your CPU) is to make your program waiting for data in a while(true) loop without using a system threading wait function.

Example 1:

while(true) {
   if (thereIsSomeDataToStream) {
       StreamDataFunction();
   }
}

In this example, if thereIsSomeDataToStream is false for a time, then CPU will still continue to work 100% performing while loop even if there is no data to stream. So this would be waste of CPU and leads your computer to slow down.

Example 2:

while(true) {
   if (thereIsSomeDataToStream) {
       StreamDataFunction();
   }
   else {
       SystemThreadingWaitFunction();
   }
}

On the contrary, in this example, when there is no more data to stream, then the thread stops for a time. Operating system will use this free time to execute other threads and, after a while, system will wake up your thread which will resume and loop again for streaming possible new data. Then there is not too much waste of CPU and your computer will remain responsive.

To perform the thread waiting procedure, you may have several possibilities:

First, you can use, as you suggested, Sleep(t). This may do the job: Sleep functions provided by compilers logically would use operating system API to idle current thread. But in this case you will have to wait all the specified time, even if some data came meanwhile. So if waiting time is too short, CPU will overwork, and if time is too long, your streaming will lag.
Or you can use operating system API directly, which I would recommend. If you are using Microsoft environnement, there are lots of waiting methods you can document on here: Microsoft wait functions API. For example you can create an Event object which will signal incoming data to stream. You can signal this event anywhere in your code or from another program. In the while loop you may then call a function like WaitForSingleObject API which will wait the event for signal state. Here is documentation on how to do this: Using event objects. I do not know about linux or other systems, but I am sure you can find it on the web. I did it few times myself, it is not so hard to code. Enjoy ! :)

score 0 · Answer 4 · answered May 16 '16 at 15:44

This is expanding on my comment above, but for the sake of completeness I am pasting what I've written in the commend here (and adding to it).

The general solution to this sort of problem is to wait for arrival of data and process it as it arrives (possibly caching newly arrived data as you're processing previously arrived data). As to the mechanics of the implementation - well, that depends on a concrete example. For example, often in a graphics processing application (games, for instance), the "game loop" is essentially what you describe (without sleeps). This is also encountered in GUI app design. For a design where the app waits for an event before processing, look to typical network client-server design.

As for the slowdown of the CPU, try the following code to observe significant slowdown:

while(true);

versus

while(true) sleep(1);

The reason the first slows down is because on each cycle the CPU checks if the condition in the loop evaluates to true (that is, in this case, if true == true). On the other hand, in the second example, the CPU checks if true == true and then sleeps for 1ms, which is significantly longer than the amount of time it takes to check true == true, freeing the CPU to do other things.

Now, as for your example, presumably processing the data inside the loop takes significantly more CPU cycles than checking true == true. So adding a sleep statement will not help, but only worsen the situation.

You should leave it to the kernel to decide when to interrupt your process to dedicate CPU cycles to other things.

Of course, take what I wrote above with a grain of salt (especially the last paragraph), as it paints a very simplistic picture not taking into account your specific situation, which may benefit from one design versus another (I don't know, because you haven't provided any details).

Is using multiple 'while()' loops bad practice?

4 Answers4