linux pthread_cond_wait/signal

每次都是有问题就让我帮忙解决，有这样的队友，不知道该喜该忧，不过也好，解决的问题越多，懂得越多，实现起需求来就越得心应手。问题大概是这样的，主线程新建了10个线程，新建完之后，主线程希望等所有新建的线程都开始执行了，再往下走。一般主线程sleep  几秒后再往下走，都能达到这样的效果，但是这样的代码要是出现在真正的项目中，那就显得太糟糕了。测试了一下，这种场景用条件变量是能实现的。代码如下：

#include<stdio.h>
#include<stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>

#define N_THREAD 10

static int thread_count = 0;
static pthread_cond_t thread_cond;
static pthread_mutex_t thread_lock;


void *thread_fun(void *arg)
{
        pthread_mutex_lock(&thread_lock);
                if(++thread_count>= N_THREAD){
                // printf("send signal\n");
                // pthread_cond_signal(&thread_cond);
                }
        printf("start thread-%d pid=%d\n",thread_count,pthread_self());
        pthread_mutex_unlock(&thread_lock);

        pthread_exit(NULL);
}

int main(int argc,char **argv)
{
        pthread_t pid[N_THREAD];
        int err;
        void *result;
        int i = 0;

        pthread_cond_init(&thread_cond, NULL);
        pthread_mutex_init(&thread_lock, NULL);
        for(i=0;i<N_THREAD;i++) {
                err = pthread_create(&pid[i],NULL,thread_fun,"hello");
                pthread_detach(pid[i]);
                printf("create thread-%d,pid=%d\n",i+1,pid[i]);
                if(err !=0){
                        printf("create thread fail ,%s\n",strerror(errno));
                }
        }

        /*wait all thread start */
     /* pthread_mutex_lock(&thread_lock);
                while(thread_count < N_THREAD){
                        pthread_cond_wait(&thread_cond,&thread_lock);
                }
        pthread_mutex_unlock(&thread_lock);*/

        printf("all thread start \n ");

        sleep(1);
        pthread_cond_destroy(&thread_cond);
        pthread_mutex_destroy(&thread_lock);
        return 0;

}

以上代码运行结果是不确定的，"all thread start " 这一句话的运行时序是随机的，如下：
执行第一次结果：

create thread-1,pid=1082132800
start thread-1 pid=1082132800
create thread-2,pid=1090525504
create thread-3,pid=1098918208
start thread-2 pid=1090525504
start thread-3 pid=1098918208
create thread-4,pid=1107310912
start thread-4 pid=1107310912
create thread-5,pid=1115703616
create thread-6,pid=1124096320
create thread-7,pid=1132489024
create thread-8,pid=1082132800
start thread-5 pid=1115703616
create thread-9,pid=1140881728
create thread-10,pid=1090525504
all thread start 
 start thread-6 pid=1132489024
start thread-7 pid=1124096320
start thread-8 pid=1090525504
start thread-9 pid=1140881728
start thread-10 pid=1082132800

执行第二次结果：

create thread-1,pid=1082132800
create thread-2,pid=1090525504
create thread-3,pid=1098918208
create thread-4,pid=1107310912
create thread-5,pid=1115703616
create thread-6,pid=1124096320
create thread-7,pid=1132489024
create thread-8,pid=1140881728
create thread-9,pid=1149274432
create thread-10,pid=1157667136
all thread start 
 start thread-1 pid=1157667136
start thread-2 pid=1115703616
start thread-3 pid=1082132800
start thread-4 pid=1090525504
start thread-5 pid=1098918208
start thread-6 pid=1107310912
start thread-7 pid=1124096320
start thread-8 pid=1132489024
start thread-9 pid=1140881728
start thread-10 pid=1149274432

这样的随机结果不是我们想要的，我们是希望所有新建的线程开始执行，主线程才往下走了。

把上面代码中的18-19，46-50 行的注释打开，每一次的执行结果"all thread start" 这一句都是最后打印的，如下：

create thread-1,pid=1082132800
start thread-1 pid=1082132800
create thread-2,pid=1090525504
create thread-3,pid=1098918208
start thread-2 pid=1090525504
create thread-4,pid=1107310912
start thread-3 pid=1098918208
create thread-5,pid=1115703616
start thread-4 pid=1115703616
start thread-5 pid=1107310912
create thread-6,pid=1124096320
start thread-6 pid=1124096320
create thread-7,pid=1132489024
start thread-7 pid=1132489024
create thread-8,pid=1140881728
create thread-9,pid=1149274432
create thread-10,pid=1157667136
start thread-8 pid=1140881728
start thread-9 pid=1149274432
send signal
start thread-10 pid=1157667136
all thread start 

当主线程新建完所有线程后，执行到47 行的时候，如果所有新建的线程都开始执行了，就不会跳到while 循环里面，阻塞在函数pthread_cond_wait上 ,只要有一个新建的线程没有开始执行条件thread_count 就成立，主线程会阻塞在phtread_cond_wait上，当最后一个新建的线程开始执行的时候，17行的条件会满足，从而调用pthread_cond_signal ,唤醒阻塞的线程，继续执行,从而达到等待所有新建线程都开始执行后，主线程再往下走的效果

ps:从上面的执行结果也能看出，先创建的线程，不一定是先执行线程处理函数的。