Linux中C语言中的线程同步

Question

I am having issue synchronizing the threads so each thread can run one job first, then another thread start the same job, and so on. Below is my code:

#include <unistd.h>
#include <sys/types.h> 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>

void handler ( void *ptr );
sem_t mutex;

int worker = 2; // number of workers
int job = 4; // number of jobs for each worker

int main()
{

    int i = 0;
    pthread_t thread_a;

    sem_init(&mutex, 0, 1);

    for (i; i < worker; i++)
    {  
       int *n_workers = malloc(sizeof(*n_workers));  
       *n_workers = i;                   
       pthread_create (&thread_a, NULL, (void *) &handler, n_workers);
    }

    pthread_join(thread_a, NULL);

    sem_destroy(&mutex);

    pthread_exit(0);
}

void handler ( void *ptr )
{
    int x = *((int *) ptr);
    int i = 0;

    for (i; i < job; i++)
    {
       sem_wait(&mutex);
       printf("Worker %d: Doing Job %d\n", x, i);  
       sem_post(&mutex);
    }
}

The output is :

Worker 1: Doing Job 0
Worker 1: Doing Job 1
Worker 1: Doing Job 2
Worker 1: Doing Job 3
Worker 0: Doing Job 0
Worker 0: Doing Job 1
Worker 0: Doing Job 2
Worker 0: Doing Job 3

In the program, each worker has 4 jobs and there are 2 workers. The problem is that worker 1 does all 4 jobs at once and worker 0 does that all jobs after it. The ideal output would be this:

Worker 0: Doing Job 0
Worker 1: Doing Job 0
Worker 0: Doing Job 1
Worker 1: Doing Job 1
Worker 0: Doing Job 2
Worker 1: Doing Job 2
Worker 0: Doing Job 3
Worker 1: Doing Job 3

I am not sure where the issue is here, any help is greatly appreciated. Thanks

Answer 1

If you want to ensure that each thread does job[n] before job[n+1], you'll need to use barriers , either by implementing them using semaphores (for that you might want to consult The Little Book of Semaphores ), or using pthread_barrier_t .

If you choose the latter, you should be able to achieve the effect with minimal modifications to your code:

#include <unistd.h>
#include <sys/types.h> 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>

void handler ( void *ptr );
pthread_barrier_t barrier;

int worker = 2; // number of workers
int job = 4; // number of jobs for each worker

int main()
{

    int i = 0;
    pthread_t thread_a;

    pthread_barrier_init(&barrier, NULL, worker);

    for (i; i < worker; i++)
    {  
       int *n_workers = malloc(sizeof(*n_workers));  
       *n_workers = i;                   
       pthread_create (&thread_a, NULL, (void *) &handler, n_workers);
    }

    pthread_join(thread_a, NULL);

    pthread_barrier_destroy(&barrier);

    pthread_exit(0);
}

void handler ( void *ptr )
{
    int x = *((int *) ptr);
    int i = 0;

    for (i; i < job; i++)
    {
       printf("Worker %d: Doing Job %d\n", x, i);  
       pthread_barrier_wait(&barrier);
    }
}

This way, each job[n] gets executed int worker = 2 times before work on job[n+1] starts. The order in which workers work on job[n] doesn't matter, so you might get different outputs, for example:

Worker 0: Doing Job 0
Worker 1: Doing Job 0
Worker 1: Doing Job 1
Worker 0: Doing Job 1
Worker 0: Doing Job 2
Worker 1: Doing Job 2
Worker 0: Doing Job 3
Worker 1: Doing Job 3

What's important is the rightmost column.

Answer 2

It seems what you want strict alternation, which is not what you have implemented in your example. What your code instead does is making sure that the your threads' "jobs" are executed by at most one thread at a time.

Now every thread, when it gets scheduled gets a 'time-slice', a maximum amount of time that the thread may run. If it is not be forced to sleep by, eg a blocking operation it will not give up the CPU until this time-slice is completely consumed. That is exactly is happening here, as the sem_wait will never block for the first thread entering your critical region. You would have to use further synchronization to implement the strict alternation, if that is what you really want.

If you do not strictly need strict alternation, but just want to see the effect of multi-threading, you can also let the threads give up CPU voluntarily by calling int pthread_yield(void); after releasing the semaphore, to give other threads the possibility to run.