C Semaphoren und eine "Barriere" zwischen Threads

Question

Ich versuche, eine Aufgabe zu lösen, die unser Professor für Betriebssysteme uns in einer früheren Prüfung gezeigt hat, um mich auf die nächste Prüfung vorzubereiten.

Das Problem besteht darin, zwei Threads zu haben, die gleichzeitig ausgeführt werden und in einer unterschiedlichen Zeitspanne abgeschlossen werden können. Nachdem ein bestimmter Thread abgeschlossen ist, muss er blockiert werden, bis der andere Thread abgeschlossen ist, dann können sie ihre Ausführung fortsetzen.

Es scheint mir konzeptionell einfach zu sein, aber mein Code funktioniert nicht so, wie ich denke, dass er sollte.

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>

#define N 10

sem_t t_1_sem;
sem_t t_2_sem;

void *thread(void *vargp);
/* shared by both threads*/
struct {
    int count;
} thread_count;

int main() {
    pthread_t tid, tid1;

    thread_count.count = 0;

    sem_init(&t_1_sem, 0, 1);
    sem_init(&t_2_sem, 0, 1);
    printf("Hello from main thread! tid:%ld pid:%d\n", pthread_self(), getpid());
    pthread_create(&tid, NULL, thread, NULL);
    pthread_create(&tid1, NULL, thread, NULL);

    pthread_join(tid, NULL);
    pthread_join(tid1, NULL);

    exit(0);
}

void *thread(void *vargp) {
    int i, tid;

    int val, val2;
    sem_getvalue(&t_1_sem, &val);
    sem_getvalue(&t_2_sem, &val2);
    printf("initial value::: %d : %d\n", val, val2);

    tid = thread_count.count;
    thread_count.count += 1;

    for(i = 0;i<N;i++){
        printf("%d, %d\n", tid, i);
        fflush(stdout);
        //sleep(0.1);
    }

    // TODO
    // barrier
    sem_getvalue(&t_1_sem, &val);
    sem_getvalue(&t_2_sem, &val2);
    printf("second value::: %d : %d\n", val, val2);
    int sem_val;
    if(tid == 0){
        // free other
        sem_getvalue(&t_1_sem, &sem_val);
        printf("posting to 2, waiting on 1 w/ %d count\n", sem_val);
        sem_post(&t_2_sem);
        // wait on this one
        sem_wait(&t_1_sem);
        printf("done waiting on 1\n");
    } else if(tid == 1){
        sem_getvalue(&t_2_sem, &sem_val);
        printf("posting to 1, waiting on 2 w/ %d count\n", sem_val);
        sem_post(&t_1_sem);
        sem_wait(&t_2_sem);
        printf("done waiting on 2\n");
    }

    sem_getvalue(&t_1_sem, &val);
    sem_getvalue(&t_2_sem, &val2);
    printf("final value::: %d : %d\n", val, val2);
    return NULL;
}

Ich erwarte, dass die beiden Threads bis 10 zählen und dann die beiden "Endwerte" angezeigt werden. printf nebeneinander geschehen. Allerdings ist das, was ich sehe, die "endgültigen Wert" Drucke auftreten, sofort nachdem der Thread beendet, zählen bis 10 - es scheint nicht zu warten.

Ich erhalte auch wirklich seltsame Werte für die sem_val Ganzzahlig drucke ich in der "Buchung nach N" printf z.B.:

Hello from main thread! tid:-1606277344 pid:5479
initial value::: 0 : 0
0, 0
initial value::: 0 : 0
1, 0
0, 1
1, 1
0, 2
1, 2
1, 3
1, 4
1, 5
0, 3
1, 6
0, 4
1, 7
0, 5
1, 8
0, 6
1, 9
0, 7
second value::: 0 : 0
posting to 1, waiting on 2 w/ -1809628646 count
0, 8
done waiting on 2
final value::: 0 : 0
0, 9
second value::: 0 : 0
posting to 2, waiting on 1 w/ -1809628646 count
done waiting on 1
final value::: 0 : 0

Irgendwelche Ideen/Hinweise?