同步线程，互斥

Question

I'm trying to do my homework but I'm stuck with these threads.. This function is called when a thread is created:

size_t* mines, gold = 0, gold_collected = 0;
pthread_mutex_t mine_mutex;
int last_mine = 0;

void* dig(void *mine_start) {
        int current_worker = (int)mine_start;
        int mine = (int)mine_start;

//      printf("Hello, it's me, thread %d\n", current_worker);

        while(gold != 0) {
                if(mine > last_mine - 1) {
                        mine = 0;
                }
                pthread_mutex_lock(&mine_mutex);
                if(mines[mine] != 0) {
                        //printf("All gold %zd\n", gold);
                        //printf("Gold in mine %zd with number %d\n", mines[mine], mine);
                        printf("Worker %d entered mine %d\n", current_worker, mine);
                        gold -= 10;
                        mines[mine] -= 10;
                        gold_collected += 10;
                        //sleep(1);    
                }
                pthread_mutex_unlock(&mine_mutex);
                ++mine;
        }
        pthread_exit(NULL);
}

My problem is that when I have 5 mines and 2 workers, only one worker gets in the mine and digs the gold. How can I rotate my threads so all of them can dig from the mine?

Answer 1

If you want 1 miner per mine, but you have more miners than mines, then you have to decide what the idle miners will do when all the mines are in use. Furthermore, if you have a mutex per mine, and everyone tries to take the first mutex, only one miner will win, and the others will still block. You can use a try lock, but then the miners will busy wait when all the mines are full.

You could use a semaphore that is initialized with the number of mines. Each miner, upon successfully acquiring the semaphore would know that there is a mine available for them, but they wouldn't know which one. You could use a single mutex to protect all of the mines' in-use state. After acquiring the semaphore, you then acquire the mutex, hunt for an available mine, mark it as in-use, release the mutex and start mining. Then, when you are done, re-acquire the mutex, mark the mine as available, release the mutex, and then release the semaphore.

Finally, instead of the semaphore, you could use a condition variable and a mutex. Acquire the mutex, and hunt for an available mine. If you cannot find one, block on the condvar. If you do find one, mark it as in use, release the mutex, and start mining. When you are done, re-acquire the mutex, mark the mine as available, signal the condvar, and release the mutex. A thread that awakes on the condvar will have automatically re-acquired the mutex and should loop around and re-hunt for an available mine. In this case, it should be sufficient to signal the condvar instead of broadcasting; although broadcasting can be safer.

Also, once you have parallel miners, you're going to have to rethink the global gold and gold_collected. Since your miners will be doing the actual mining without holding a mutex, they cannot update these globals while mining. They should keep a local tally of the amount of gold they mined, and update the global once the mutex has been re-acquired. Maybe gold can be deducted before the miner enters the mine, and gold_collected updated after leaving the mine (both while holding the mutex). It's also a little iffy reading gold when not holding the mutex, since it could change underneath you...

Answer 2

There is only one mutex for both mines, so only one worker can be working in the mines. If you have one mutex per mine, then two workers can enter in mines at same time (one worker in each mine).