停止主线程，直到所有其他线程完成

Question

I want to stop the main thread until all the other threads finishes running. Is there any possible way to do that using pthreads in C? Is there any possible way to sleep the main thread?

Here is the code I used to test.

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

int a = 4;

void *func(void *arg)
{
    for (int i = 0; i < 5; i++)
    {
        sleep(1);
        printf("MY TURN : %d\n", i);
    }
}

void *func_2(void *arg)
{
    for (int i = 0; i < 5; i++)
    {
        sleep(1);
        printf("YOUR TURN : %d\n", i);
    }
}

void turn()
{
    for (int i = 0; i < 5; i++)
    {
        sleep(1);
        printf("THEIR TURN : %d \n", i);
    }
}

int main()
{
    pthread_t t_id, t_id_2;

    pthread_create(&t_id, NULL, func, NULL);
    pthread_create(&t_id_2, NULL, func_2, NULL);

    turn();

    pthread_join(t_id, NULL);
    pthread_join(t_id_2, NULL);
}

Output of the code

THEIR TURN : 0
YOUR TURN : 0
MY TURN : 0
MY TURN : 1
THEIR TURN : 1
YOUR TURN : 1
MY TURN : 2
THEIR TURN : 2
YOUR TURN : 2
MY TURN : 3
THEIR TURN : 3
YOUR TURN : 3
MY TURN : 4
THEIR TURN : 4
YOUR TURN : 4

I want to run the turn() (function which is in main function) after running t_id and t_id_2 threads.

Answer 1

What you want is actually exactly what the pthread_join function does.

From man pthread_join :

int pthread_join(pthread_t thread, void **retval);

The pthread_join() function waits for the thread specified by <thread> to terminate.
If that thread has already terminated, then pthread_join() returns immediately.
The thread specified by <thread> must be joinable.

So in your main function you can just join the threads before calling turn :

pthread_t t_id, t_id_2;

pthread_create(&t_id, NULL, func, NULL);
pthread_create(&t_id_2, NULL, func_2, NULL);

pthread_join(t_id, NULL);
pthread_join(t_id_2, NULL);

turn();

return 0;

That way turn is called after the thread functions finish their work.

Answer 2

The classic way to wait for a thread is join() or pthread_join(), and that means the join caller must know all the thread ids, and the thread subroutines must return (terminate).

As thread pools and multiple pass problems came into vogue, non-terminal signalling like barrier() or pthread_barrier_init()/pthread_barrier_wait() became more common. The latter is a bit like a semaphore, with a thread count but also with one 'master' thread getting a unique return. In practice, barriers are often used in pairs, one for "are we all done this pass" with the unique 'master' thread delivering the result of the pass and another barrier to hold up the rest until the result is delivered by the 'master' thread before the problem pass variables can be modified in the next pass.