Synchronization — Exam Drill Pack Unit u07 · 13 real exercises from the 2022–2025 exams · answers verified against the official solutions

Tip: trace / tick first, then reveal.
init(a,0);  init(b,1);

T1              T2              T3
wait(a);        wait(b);        wait(a);
printf("1");    printf("2");    printf("5");
signal(a);      signal(a);      signal(a);
signal(b);      wait(a);        signal(b);
                printf("3");
                wait(b);
                printf("4");
                signal(a);
sem_init(s,0,1);  i=0; n=1;     // 3 threads run T('A'), T('B'), T('C')

T(p):
  c = *p; pthread_detach(self);
  while (1) {
    sem_wait(s);
    printf("%c", c);
    i++;
    if (i>=n) { printf("-"); i=0; n++; if (n>=4) n=1; }
    sem_post(s);
  }
n=0; sem_init(sa,0,1); sem_init(sc,0,1); sem_init(sac,0,1); sem_init(sb,0,0);

TA():                       TC():                       TB():
  sem_wait(sa);               sem_wait(sc);               sem_wait(sb);
  sem_wait(sac);              sem_wait(sac);              printf("Y ");
  printf("X ");               printf("Z ");               sem_post(sac);
  n++;                        n++;
  if(n==1) sem_post(sb);      if(n==1) sem_post(sb);
  else { n=0;                 else { n=0;
    sem_post(sa);                 sem_post(sa);
    sem_post(sc);                 sem_post(sc);
    sem_post(sac); }              sem_post(sac); }
// arc P6->P1 is superfluous (P6->P5->P1 already enforces it)
init(p1,1); init(p2,0); init(p3,0); init(p4,0); init(p5,0); init(p6,0);

P1: while(1){ wait(p1);  /*P1*/  signal(p2); signal(p3); signal(p4); }
P2: while(1){ wait(p2);  /*P2*/  signal(p5); }
P3: while(1){ wait(p3);  /*P3*/  signal(p5); }
P4: while(1){ wait(p4);  /*P4*/  signal(p6); }
P6: while(1){ wait(p6);  /*P6*/  signal(p5); }
P5: while(1){ wait(p5); wait(p5); wait(p5);  /*P5*/  signal(p1); }
typedef struct {
  int count;                /* the counter */
  pthread_mutex_t lock;     /* protects count */
  pthread_mutex_t s;        /* the blocking gate */
} Semaphore;

void semaphore_init(Semaphore *s, int i){
  pthread_mutex_init(&s->lock, NULL);
  pthread_mutex_init(&s->s, NULL);
  pthread_mutex_lock(&s->s);            // hold the gate
  s->count = i;
}
void semaphore_wait(Semaphore *s){
  pthread_mutex_lock(&s->lock);
  s->count--;
  if (s->count < 0){
    pthread_mutex_unlock(&s->lock);
    pthread_mutex_lock(&s->s);          // block here
  } else
    pthread_mutex_unlock(&s->lock);
}
void semaphore_signal(Semaphore *s){
  pthread_mutex_lock(&s->lock);
  s->count++;
  if (s->count <= 0)
    pthread_mutex_unlock(&s->s);        // wake one waiter
  pthread_mutex_unlock(&s->lock);
}
sem_t s1, s2, b;   int first = 1;
sem_init(&s1,0,1); sem_init(&s2,0,0); sem_init(&b,0,0);

// TA                            // TC
while(1){                        while(1){
  sem_wait(&s1);                  sem_wait(&s1);
  printf("A");                     printf("C");
  if(first){ first=0;              if(first){ first=0;
    sem_post(&s2);                   sem_post(&s2);
    sem_wait(&b);                    sem_wait(&b);
    sem_post(&s1); }                 sem_post(&s1); }
  else { first=1; sem_post(&b); }  else { first=1; sem_post(&b); }
}                                }

// TB
while(1){ sem_wait(&s2); printf("B"); sem_post(&s1); }