C线程同步

Question

I have a problem of using multiple threads and sync them in a proper order. The problem states the following: I have 44 threads from 1-44. I can have a maximum of 4 threads that can enter the critical area at a moment. Thread number 12 must close only when there are 4 threads in the critical area, including them. The problem is the following: sometimes the thread closes well, sometimes it doesn't. I don't know when it is going to come, it might be the last one, so i forced it to be the first one that enters the critical area. This is the code sample that sync the 44 threads:

void *thread_sync_P7(void *arg){
    int *val = (int*)arg;

    if(*val != 12) {
        sem_wait(&semP7_2);
    }

    sem_wait(&semP7_1);
    info(BEGIN, 7, *val);

    if(*val == 12) {
        sem = 0;
        for(int i = 0;i < threadP7 - 1;i++){
            sem_post(&semP7_2);
        }
    }


    info(END, 7, *val);
    sem_post(&semP7_1);

    return NULL;   
}

sempP7_1 sync the critical area to stop more than 4 threads being there at one, and semP7_2 makes sure that the first thread to enter the area is thread with id 12. Sometimes this happens:

[T] BEGIN P7 T12 pid=24850 ppid=24848 tid=825038592

[T]  END  P4 T3 pid=24848 ppid=24846 tid=900572928

[T] BEGIN P7 T2 pid=24850 ppid=24848 tid=908965632

[T]  END  P4 T1 pid=24848 ppid=24846 tid=917358336

[T] BEGIN P7 T3 pid=24850 ppid=24848 tid=900572928

[T]  END  P5 T0 pid=24851 ppid=24847 tid=925882176

[T]  END  P7 T12 pid=24850 ppid=24848 tid=825038592

[T] BEGIN P7 T4 pid=24850 ppid=24848 tid=892180224

As you can see, P7 T12 is the thread with id 12. It is followed by T2 an T3, but it closes and there are only 3 threads displayed. How can i sync them better?

Answer 1

You have several ways to implement this:

1. (waiting) Use a condition variable associated with the final condition. Your thread number 12 will be waiting for that condition to be true, and the other threads will evaluate the condition and awaken it when the condition becomes true. As each thread enters into the critical region, it evaluates the condition and if true, awakens the thread. As each thread gets out of the critical region, reevaluates the condition (this mean to increment/decrement a variable with the number of threads in the critical region) Onde the thread 12 is awaken, it can close (with closing meaning whatever you want) In this case your thread is waiting for the condition to happen to close .

2. (polling) In case your thread has something to do until it is about to decide if to close or not to close , just evaluate the condition on the other threads on entry to the critical region and store it (you need a critical region nested on the first to achieve this). You can have also a boolean variable indicating if the condition has been reached in the past (we have already reached the four threads inside, even if now there are not those four threads) Then, your thread has freedom to make another task and only evaluate if it has to close at certain points in time.

3. (signalled) In case you have to asynchronously signal the process to leave what it can be doing and close , just send it a signal. This will interrupt the thread execution and you can decide to abort your task or continue after the signal on your signal handler. Beware that handling signals (you send signals to a process, which normally is a group of threads) and attaching them to specific threads of a process is something difficult to properly achieve, you have to decide which threads are going to handle what kind of signals, and this is an elaborate thing.