【C语言_线程pthread_互斥锁mutex_条件触发cond 之解析与示例 (开源)】.md updata:23/11/03

线程 pthread

线程 vs 进程

线程：直接用主程序的内存地址，所以如果在线程里改主程序变量，就是直接改；
线程vs进程：
a.比进程快大概30倍，不需要复制完全一样的内存来创建运行，直接使用主程序的内存；
b.没有进程那么健壮，子线程蹦了，就都崩了；
而对进程而言，子进程崩了，父进程不受影响继续执行；

线程退出 等待 消息传递

join:等待，传参void*； exit:退出，对参数赋值void**;

#include stdio.h>
#include pthread.h>
#include string.h>

//创建线程
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// 返回：若成功返回0，否则返回错误编号

//子线程执行函数func1里的pthread_exit负责将void* 传递给主线程的pthread_joi的void **参数；
//int pthread_exit(void *rval_ptr);

// int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号

void *func1(void * arg)
{
    static char data[] = "I am ok! thanks!";
    printf("t1 id:%dn",(int)pthread_self());
    printf("t1 arg data:%sn",(char* )arg);
    pthread_exit((void* )data);
}

int main()
{
    pthread_t t1;
    cha服务器托管网r arg[] = "Are you ok?";
    char data1[1024];
    memset(data1,'',sizeof(data1));

    printf("main id:%dn",(int)pthread_self());
    int creatN = pthread_create(&t1,NULL,func1, (void*)arg); 
    //创建其他线程，也是类似操作： 定义好执行函数func2，和传入的形参arg2即可；
    //pthread_create(&t2,NULL,func2, (void*)arg2); 

    void* ret;
    pthread_join(t1,&ret);
    strcpy(data1, (char*)ret);
    printf("t1 return data:%sn",data1);
    return 0;
}

互斥锁 mutex

互斥锁：我上锁，你就不能用了，除非我解锁了，你才能用；
配合线程使用；

互斥锁mutex+条件cond_等待wait、触发signal 控制线程执行

//例：

#include stdio.h>
#include pthread.h>
#include string.h>
#include unistd.h>

/*-----------------------------------------------------*/
// 创建互斥锁变量 
//pthread_mutex_t 锁名
// 初始化及销毁互斥锁
// int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
// int pthread_mutex_destroy(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号

//上锁 例：pthread_mutex_lock(&mutex);
//解锁 例：pthread_mutex_unlock(&mutex);

/*-----------------------------------------------------*/

// 创建条件变量 
//pthread_cond_t 条件名
// 初始化及销毁条件变量
// int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); //消息只给一个线程
// int pthread_cond_destroy(pthread_cond_t *cond);  //广播给所有线程
// 返回：若成功返回0，否则返回错误编号

// 等待
// int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
// int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号

//触发
// int pthread_cond_signal(pthread_cond_t *cond);
// int pthread_cond_broadcast(pthread_cond_t *cond);
// 返回：若成功返回0，否则返回错误编号

/*-----------------------------------------------------*/

int numNB = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void * arg)
{
    printf("t1 id:%ldn",(unsigned long)pthread_self());
    printf("t1 get main data:%sn",(char* )arg);
    
    while(1){
        pthread_cond_wait(&cond,&mutex);
        printf("--------------------n");
        printf("t1:%dn",numNB++);
        printf("--------------------n");
        sleep(1);
        numNB = 0;
    }

}

void *func2(void * arg)
{
    printf("t2 id:%ldn",(unsigned long)pthread_self());
    printf("t2 get main data:%sn",(char* )arg);
    while(1){
        pthread_mutex_lock(&mutex);                
        printf("t2:%dn",numNB++);
        pthread_mutex_unlock(&mutex);
        
        if(numNB == 3){
           pthread_cond_signal(&cond); 
        }     
        sleep(1);   
    } 
}

int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);
    pthread_t t1,t2;
    void* ret;
    char arg[] =服务器托管网 "Are you ok?";
    char data1[1024];
    memset(data1,'',sizeof(data1));
    
    int creatN1 = pthread_create(&t1,NULL,func1, (void*)arg);
    int creatN2 = pthread_create(&t2,NULL,func2, (void*)arg);
    
    printf("main id:%ldn",(unsigned long)pthread_self());

    pthread_join(t1,&ret);
    pthread_join(t2,&ret);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

补充: 宏-静态初始化 互斥锁/条件

//在main函数里，不用宏，pthread_mutex_init() 正常初始化锁/条件的，即为动态初始化
//例：
pthread_mutex_t mutex;
int main()
{
    pthread_mutex_init(&mutex,NULL);
    return 0;
}

//在定义互斥锁/条件变量时，使用默认宏直接完成初始化，即为静态初始化
//例：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: 飞码LowCode前端技术系列：如何便捷快速验证实现投产及飞码探索 | 京东云技术团队

从数据到大模型应用，11 月 25 日，杭州源创会，共享开发小技巧 本篇文章从数据中心，事件中心如何协议工作、不依赖环境对vue2.x、vue服务器托管网3.x都可以支持、投产页面问题定位三个方面进行分析。 一、数据中心，事件中心设计 飞码是数据驱动+事件驱动…