You can implement a fair queuing system where each thread is added to a queue when it blocks, and the first thread on the queue always gets the resource when it becomes available. Such a “fair” ticket lock built on pthreads primitives might look like this: #include <pthread.h> typedef struct ticket_lock { pthread_cond_t cond; pthread_mutex_t … Read more
Do pthread_mutex_lock and pthread_mutex_unlock functions call memory fence/barrier instructions? They do, as well as thread creation. Note, however, there are two types of memory barriers: compiler and hardware. Compiler barriers only prevent the compiler from reordering reads and writes and speculating variable values, but don’t prevent the CPU from reordering. The hardware barriers prevent the … Read more
Yes. This is a common way to design multithreaded servers and accepted design practice. You can also fork several times and have the child processes call accept, this will allow you to do multithreading without needing a threads library. Older servers do this.
Condition variables should be used as a place to wait and be notified. They are not the condition itself and they are not events. The condition is contained in the surrounding programming logic. The typical usage pattern of condition variables is // safely examine the condition, prevent other threads from // altering it pthread_mutex_lock (&lock); … Read more
As long as you are using locks to control access to the variable, you do not need volatile on it. In fact, if you’re putting volatile on any variable you’re probably already wrong. https://software.intel.com/en-us/blogs/2007/11/30/volatile-almost-useless-for-multi-threaded-programming/
It sounds like you have two questions here: How can I wait until my thread completes? Answer: This is directly supported by pthreads — make your thread-to-be-stopped JOINABLE (when it is first started), and use pthread_join() to block your current thread until the thread-to-be-stopped is no longer running. How can I tell if my thread … Read more
If your goal is to have the main thread wait for all threads to reach the same point before continuing onward, I would suggest using pthread_barrier_wait: void worker(void*); int main(int argc, char **argv) { pthread_barrier_t b; pthread_t children[TCOUNT]; int child; /* +1 for our main thread */ pthread_barrier_init(&b, NULL, TCOUNT+1); for (child = 0; child … Read more
You might try using the -pthread option to g++. -pthread Adds support for multithreading with the pthreads library. This option sets flags for both the preprocessor and linker.
Yes, it is the signature of a nameless function pointer that takes and returns void *. If it had a name (as in a variable) it would be: void *(*myFuncName)(void*)
A thread’s resources are not immediately released at termination, unless the thread was created with the detach state attribute set to PTHREAD_CREATE_DETACHED, or if pthread_detach is called for its pthread_t. An undetached thread will remain terminated state until its identifier is passed to pthread_join or pthread_detach. To sum it up, you have three options: create … Read more