线程同步中的锁和信号量

墨蓝 2022-12-17 02:25 173阅读 0赞

#### 由于工作上用到线程之间的同步，而且有超时处理，问题是：子主线程等待的时候已经加锁了，为什么主线程中还可以再去加锁给子线程发送信号呢？ ####

##### pthread\_cond\_timedwait()函数有三个入口参数： #####

1.  pthread\_cond\_t \_\_cond：条件变量（触发条件）
2.  pthread\_mutex\_t \_\_mutex: 互斥锁
3.  struct timespec \_\_abstime: 等待时间（其值为系统时间 + 等待时间)

##### 当在指定时间内有信号传过来时，pthread\_cond\_timedwait()返回0，否则返回一个非0数; #####

##### 在使用pthread\_cond\_timedwait()函数时，必须有三步： #####

1.  加互斥锁：pthread\_mutex\_lock(&\_\_mutex)
2.  等待：pthread\_cond\_timedwait(&\_\_cond, &\_\_mutex, &\_\_abstime) //解锁->等待->加锁
3.  解互斥锁：pthread\_mutex\_unlock(&\_\_mutex)

##### 发送信号量时，也要有三步： #####

1.  加互斥锁：pthread\_mutex\_lock(&\_\_mutex)
2.  发送：pthread\_cond\_signal(&\_\_cond)
3.  解互斥锁：pthread\_mutex\_unlock(&\_\_mutex)

##### 问题解答：其实这是因为在pthread\_cond\_timedwait()函数中已经对互斥锁进行解锁操作了，所以这个时候发送信号量是不会阻塞的。 #####

测试代码：

#include <stdio.h>
    #include <pthread.h>
    #include <string.h>
    #include <unistd.h>
    #include <time.h>
    #include <semaphore.h>
    #include <sys/time.h>
     
    #define SENDSIGTIME 3
     
    pthread_cond_t g_cond;
    pthread_mutex_t g_mutex;
     
    char time_tmp[128] = "";
    char *display_time(void){ 
    	struct timeval tv;
    	struct timezone tz;
    	struct tm *tp;
    	gettimeofday(&tv, &tz);
    	tp=localtime(&tv.tv_sec);
    	memset(time_tmp, 0, sizeof(time_tmp));
    	sprintf(time_tmp, "%4d-%02d-%02d %02d:%02d:%02d.%06d",1900+tp->tm_year, 1+tp->tm_mon, tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec, (int)(tv.tv_usec));
    	return time_tmp;
    }
    
    void* thread_fun(void *arg){ 
        int ret = 0;
        struct timeval now;
        struct timespec outtime;
    	
    	printf("[%s] %s lock\n", display_time(), __FUNCTION__);
        pthread_mutex_lock(&g_mutex);
     
        gettimeofday(&now, NULL);
        outtime.tv_sec = now.tv_sec + 5;
        outtime.tv_nsec = now.tv_usec * 1000;
    	
    	printf("[%s] %s wait\n", display_time(), __FUNCTION__);
        ret = pthread_cond_timedwait(&g_cond, &g_mutex, &outtime);
        //ret = pthread_cond_wait(&g_cond, &g_mutex);
    	printf("[%s] %s recv signal ret:%d\n", display_time(), __FUNCTION__, ret);
        pthread_mutex_unlock(&g_mutex);
     
        printf("[%s] %s unlock end\n", display_time(), __FUNCTION__);
     
    }
     
    int main(int argc, char* argv[]){ 
        pthread_t pid;
        int ret;
     
        pthread_cond_init(&g_cond, NULL);
        pthread_mutex_init(&g_mutex, NULL);
     
        ret = pthread_create(&pid, NULL, (void *)thread_fun, NULL);
        if (0 != ret){ 
    		perror("create thread!\n");
    		return 1;
        }
     
        printf("[%s] %s Wait %ds send signal\n", display_time(), __FUNCTION__, SENDSIGTIME);
        sleep(SENDSIGTIME);
        printf("[%s] %s Lock\n", display_time(), __FUNCTION__);
        pthread_mutex_lock(&g_mutex);
    	printf("[%s] %s Send signal\n", display_time(), __FUNCTION__);
        pthread_cond_signal(&g_cond);
    	printf("[%s] %s Send signal end\n", display_time(), __FUNCTION__);
        pthread_mutex_unlock(&g_mutex);
    	printf("[%s] %s Send unlock end\n", display_time(), __FUNCTION__);
     
        pthread_join(pid, NULL);
     
        pthread_cond_destroy(&g_cond);
        pthread_mutex_destroy(&g_mutex);
     
        return 0;
    }

运行结果：  
![在这里插入图片描述][20201021151405112.png_pic_center]

[20201021151405112.png_pic_center]: /images/20221123/cff91f5490f04c338dc1f3222c65934d.png