How to stop and continue pthread?

Question

I code in C (actually in OOC, which is then compiled to C).

How can I instruct a thread to wait at a specific checkpoint until some other thread asks it to continue?

I am using a hard thread in a thread and polling a variable that I am changing from the main thread, but I think this doesn't work very well, right? Also, when I make a tight loop in the thread, should I enable sleep mode in the loop to avoid overuse of the processor loop?

Answer 1

It seems that you are looking for pthread_cond_wait and related functions.

Here is a quote from the manpage with an example:

Consider two common variables x and y, protected by mutex mut, and the conditional variable cond, which should be signaled whenever x becomes greater than y.

  int x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

Waiting until x is greater than y is as follows:

  pthread_mutex_lock(&mut); while (x <= y) { pthread_cond_wait(&cond, &mut); } /* operate on x and y */ pthread_mutex_unlock(&mut); 

Modifications in x and y, which can lead to x becoming larger than y, should signal the condition if necessary:

  pthread_mutex_lock(&mut); /* modify x and y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut); 

In the end, it does what you ask: the thread calling pthread_cond_wait(&cond) is blocked until another thread (like your main thread) calls pthread_cond_broadcast(&cond) . During this time, it is in a blocked state and does not consume processor cycles.

Answer 2

I think a good candidate for a fortune. A thread must wait for a state, and another thread must signal a state for this thread to continue.

you can find pthread_cond_init, which should lead to other functions

Answer 3

You should learn the correct synchronization primitives, such as mutexes, condition variables, and semaphores. In this case, it sounds like a condition variable - the most suitable tool from the pthreads library.

Answer 4

Just to let you know what’s going on, a hard loop consumes the allocation of your processor thread just like any other code executed by your thread. The only difference is that it does nothing. Well, I think creating a heart tone is something ... You probably will never want to do this unless you care about the cost of the context switch, and you know for sure that the wait time will be much shorter than your stream time, which is about 1 ms. I don’t know if the dream is as bad as the crop (AFAIK output gives you the thread of the thread list thread to activate at your priority level), but both at least carry a penalty for the context switch. There is a cost of context switching. A context switch is what happens when your time stream ends. This may end because you ended it with damage or sleep, or if the core finished it, having previously released you. Read about SMP and spinlocks to learn more about context switches and when a compressed loop applies.

In addition, when you sleep, you do not know exactly when you will wake up again. therefore, one of the reasons you might not want to sleep is to do something quickly. You can wait a couple of ms before being ported.

Everyone else has provided you with the pthread_cond_wait solution, which requires locking through mutexes and looks simple and simple. Performance may be appropriate for your needs, but relatively slow compared to a solution using signals ( sigwait and pthread_kill ). Difficulty will sneak up on you.

It is not discussed here why you block the mutex before testing if you need to wait for the state. The reason is that such code has a flaw:

  while (x <= y) { pthread_cond_wait(&cond, &mut); } 

Your thread can check (X <= Y), see that it should wait, but is preceded before it joins the condition value. Some other thread that has just changed x or y signals the state in this temporary sheet before the first thread joins the condition. Thus, the status signal is lost. So what happens, wherever you change the variables that improve the signal, you need to add locks.

  pthread_mutex_lock(&mut); /* modify x and y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut); 

This may mean that you add these mutex locks in many different places, and because of this, your code becomes more complex and slow. The possibility of a hanging thread awaiting conditions is always present. In solving the cycle, test, sleep, none of these problems exist. Therefore, if the waiting time is known to be short, using sleep in a cycle is probably the perfect solution. Especially if you can sleep for a second or more between trials. If you can, don’t worry about mutexes and conditions. If the sleep time is short, for example, 1 ms, and the wait time is long, for example, minutes or hours, then in the end you lose resources, constantly waking up and returning to sleep. You must judge.

Also keep in mind that sometimes the core will try to wake the waiter's flow, and in other cases there will be a delay. If the thread wakes up too early, it will wake up when the mutex is locked and will immediately return to sleep until the mutex is unlocked. If this becomes a problem, report it as follows:

 pthread_mutex_lock(&mut); /* modify x and y */ if (x > y) { pthread_mutex_unlock(&mut); pthread_cond_broadcast(&cond); } else pthread_mutex_unlock(&mut); 

Thank you for using user576875 who copied the code samples.