For a joinable (i.e NOT detached) pthread you could use pthread_kill like this: int ret = pthread_kill(YOUR_PTHREAD_ID, 0); If you get a ESRCH value, it might be the case that your thread is dead. However this doesn’t apply to a detached pthreads because after it has ended its thread ID can be reused for another … Read more
It is both complicated and differs from Unix to Unix variant. In Linux, for example, a system called Futex (Short for Fast Userspace Mutex) is used. In this system an atomic increment and test operation is performed on the mutex variable in user space. If the result of the operation indicates that there was no … Read more
You are right in saying that the order of thread execution is not sequential. To some extent, that is the whole point of using threads, i.e. to run other tasks concurrently. The output you are seeing is as expected, and can possibly be different. Perhaps this will help: main thread1 thread2 | |–create——–+———–\ | | … Read more
I will just put this code here. It is not panacea, as it doesn’t deal with FreeBSD, but it is helpful in most cases when all you need is to support Windows and and say Debian. Of course, the clean solution assumes usage of CRYPTO_THREADID_* family introduced recently. (to give an idea, it has a … Read more
You can use a mutex, condition variable, and a shared flag variable to do this. Let’s assume these are defined globally: pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; int play = 0; You could structure your playback code like this: for(;;) { /* Playback loop */ pthread_mutex_lock(&lock); while(!play) { /* We’re paused */ pthread_cond_wait(&cond, … Read more
Oh, this was was a pain! I probably lost 2 hours on this. Here is the solution: CMake uses short ‘C’ applications to test/try things. If the CMakeLists.txt states that C++ is used for the project, without also listing C, then some of those shorts tests incorrectly fail, and cmake then thinks those things aren’t … Read more
For me the best answer was the comment from pts if only he bothered to submit it as answer: You investigated properly and answered your own question. Use g++ -pthread, it is equivalent to g++ -lpthread -D_REENTRANT. Using g++ -D_REENTRANT would be different, it may not set all the linker flags. – pts May 18 … Read more
The process received a SIGPIPE. The default behaviour for this signal is to end the process. A SIGPIPE is sent to a process if it tried to write to a socket that had been shutdown for writing or isn’t connected (anymore). To avoid that the program ends in this case, you could either make the … Read more
To resurrect this old thread, I just did some simple test code: #include <thread> int main(int argc, char** argv) { for (volatile int i = 0; i < 500000; i++) std::thread([](){}).detach(); return 0; } I compiled it with g++ test.cpp -std=c++11 -lpthread -O3 -o test. I then ran it three times in a row on … Read more
Pthreads and OpenMP represent two totally different multiprocessing paradigms. Pthreads is a very low-level API for working with threads. Thus, you have extremely fine-grained control over thread management (create/join/etc), mutexes, and so on. It’s fairly bare-bones. On the other hand, OpenMP is much higher level, is more portable and doesn’t limit you to using C. … Read more