Consider this attempt at thread_join using a condition varia…

Consider this attempt at thread_join using a condition variable but NO state variable: void thread_join() { mutex_lock(&m); cond_wait(&cv, &m); mutex_unlock(&m); } void thread_exit() { mutex_lock(&m); cond_signal(&cv); mutex_unlock(&m); } Under what circumstance does this implementation fail?

Consider a system with three threads and three locks (A, B,…

Consider a system with three threads and three locks (A, B, C) (assume any locks held are eventually freed in each thread, after these operations): Thread 1: lock(A); lock(B); lock(C) Thread 2: lock(B); lock(C); unlock(B); lock(A) Thread 3: lock(C); lock(A) Which pair(s) of threads can deadlock with each other?

Consider a bounded buffer with one producer and two consumer…

Consider a bounded buffer with one producer and two consumers using a single condition variable and while loops: void *producer(void *arg) { mutex_lock(&m); while (count == MAX) cond_wait(&cv, &m); buffer_add(item); count++; cond_signal(&cv); mutex_unlock(&m); } void *consumer(void *arg) { mutex_lock(&m); while (count == 0) cond_wait(&cv, &m); item = buffer_get(); count–; cond_signal(&cv); mutex_unlock(&m); } What can go wrong with this code?

Consider a concurrent linked list with hand-over-hand (lock…

Consider a concurrent linked list with hand-over-hand (lock coupling) locking: each node has its own lock, and a thread traversing the list locks the next node before unlocking the current one. Compared to using a single coarse-grained lock for the entire list, what is the main advantage of this approach?