Question

I have the following scenario:

I have multiple worker threads running that all go through a certain section of code, and they’re allowed to do so simultaneously. No critical section surrounds this piece of code right now as it’s not required for these threads.

I have a main thread that also -occassionally- wants to enter that section of code, but when it does, none of the other worker threads should use that section of code.

Naive solution: surround the section of code with a critical section. But that would kill a lot of parallelism between the worker threads, which is important in my case.

Is there a better solution?

Answer 1

Use RW locks. RW locks allow multiple readers and only a single writer. Your workers would call read-lock at the start of the critical section and the main thread would write-lock.

By definition, when calling read-lock, the calling process will wait for any writing threads to finish. When calling write-lock, the calling process will wait for any reading or writing threads to finish.

Example using POSIX threads:

pthread_rwlock_t lock;
/* worker threads */
void *do_work(void *args) {
    for (int i = 0; i < 100; ++i) {
        pthread_rwlock_rdlock(&lock);
        // do some work...
        pthread_rwlock_unlock(&lock);
        sleep(1);
    }
    pthread_exit(0);
}

/* main thread */
int main(void) {
    pthread_t workers[4];
    pthread_rwlock_init(&lock);
    int i;

    // spawn workers...
    for (i = 0; i < 4; ++i) {
        pthread_create(workers[i]; NULL, do_worker, NULL);
    }
    for (i = 0; i < 100, ++i) {
        pthread_rwlock_wrlock(&lock);
        // do some work...
        pthread_rwlock_unlock(&lock);
        sleep(1);
    }

    return 0;
}