第三章 Linux多线程开发

最新推荐文章于 2024-11-05 18:02:41 发布
最新推荐文章于 2024-11-05 18:02:41 发布
阅读量129 收藏 2
点赞数
文章标签： linux java 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45812901/article/details/129482743
版权
本文详细介绍了Linux环境下多线程的概念和编程实践，包括线程与进程的区别、线程的创建（pthread_create）和终止（pthread_exit）、线程同步（互斥锁、读写锁、条件变量和信号量）以及线程的资源管理。通过示例代码演示了如何在C语言中实现线程的创建、同步和销毁，强调了避免死锁和数据竞争的重要性。
摘要由CSDN通过智能技术生成

1 线程概述

01 线程概述在这里插入图片描述

02 线程和进程的区别

在这里插入图片描述
创建进程虽然使用了写时复制技术，但是仍然要复制父进程的信息，而创建线程，线程间是共享虚拟地址空间

03 线程和进程虚拟地址空间

在这里插入图片描述
创建一个进程，就是把原先的地址空间拷贝一下，如果只读那么他们共享虚拟内存空间，如果要写就需要拷贝一个虚拟内存空间，与真实的内存做一个映射
创建一个线程，是和原来的共用一个虚拟空间，但是里面的栈空间会开辟成一个个的单独空间，代码段（.text段）也是会划分成一个个单独空间

04 线程之间共享和非共享资源

在这里插入图片描述

05 NPTL

在这里插入图片描述

2 创建线程

06 线程操作

在这里插入图片描述
线程的创建

/*
    一般情况下,main函数所在的线程我们称之为主线程（main线程），其余创建的线程
    称之为子线程。
    程序中默认只有一个进程，fork()函数调用，2进行
    程序中默认只有一个线程，pthread_create()函数调用，2个线程。

    #include <pthread.h>
    int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
    void *(*start_routine) (void *), void *arg);

        - 功能：创建一个子线程
        - 参数：
            - thread：传出参数，线程创建成功后，子线程的线程ID被写到该变量中。
            - attr : 设置线程的属性，一般使用默认值，NULL
            - start_routine : 函数指针，这个函数是子线程需要处理的逻辑代码
            - arg : 给第三个参数使用，传参
        - 返回值：
            成功：0
            失败：返回错误号。这个错误号和之前errno不太一样。
            获取错误号的信息：  char * strerror(int errnum);

*/

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

void *callback(void *arg){
    printf("child thread....\n");
    printf("arg value : %d \n",*(int *)arg);
    return NULL;
}

int main(){

    pthread_t tid;

    int num = 10;

    // 创建一个子线程
    int ret = pthread_create(&tid,NULL,callback,(void *)&num);
    if(ret != 0){
        // 不正常
        char * errstr = strerror(ret);
        printf("error : %s \n",errstr);
    }

    for(int i = 0;i<5;++i){
        printf("%d \n",i);
    }

    sleep(1);

    return 0;
}

在这里插入图片描述

3终止线程

/*
    #include<pthread.h>
    void pthread_exit(void *retval);
        功能：终止一个线程，在哪个线程中调用，就表示终止哪个线程
        参数：
            retval：需要传递一个指针，作为一个返回值，可以在pthread_join()中获取到

    pthread_t pthread_self(void);
        功能：获取当前的线程的线程ID

    int pthread_equal(pthread_t t1, pthread_t t2);
        功能：比较两个线程ID是否相等
        不同的操作系统，pthread_t类型的实现不一样，有的是无符号的长整型，有的
        是使用结构体去实现的。
*/

#include<stdio.h>
#include<pthread.h>
#include<string.h>
void *callback(void * arg){
    printf("child thread id : %ld\n",pthread_self());
    return NULL; //pthread_exit(NULL);
}

int main(){
    //创建一个子线程
    // pthread_t 用来声明线程的id
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error : %s\n",errstr);
    }

    //主线程
    for(int i =0;i<5;++i){
        printf("%d\n",i);
    }

    printf("tid : %ld, main thread id : %ld \n",tid,pthread_self());

    //让主线程退出，当主线程退出时，不会影响其他正常运行的线程
    pthread_exit(NULL);

    printf("main thread exit\n");

    return 0;

}

在这里插入图片描述

4 连接已终止的线程

/*
    #include<pthread.h>
    int pthread_join(pthread_t thread, void **retval);
        功能：和一个已经终止的线程进行连接
              回收子线程的资源
              这个函数是阻塞函数，调用一次只能回收一个子线程
              一般在主线程中使用
        
        参数：
            thread：需要回收的子线程的ID
            retval：接收子线程退出时的返回值
        返回值：
            0：成功
            非0：失败，返回的错误号
*/
#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<unistd.h>

int value = 10;

void *callback(void * arg){
    printf("child thread id : %ld\n",pthread_self());
    sleep(3);
    //return NULL; //pthread_exit(NULL);
    //int value = 10; // 局部变量，在子线程结束的时候，栈空间会释放掉，数据也就消失了，应该定义一个全局变量
    pthread_exit((void *)&value);
}

int main(){
    //创建一个子线程
    // pthread_t 用来声明线程的id
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error : %s\n",errstr);
    }

    //主线程
    for(int i =0;i<5;++i){
        printf("%d\n",i);
    }

    printf("tid : %ld, main thread id : %ld \n",tid,pthread_self());

    // 主线程调用pthread_join（）回收子线程的资源
    // 如果子线程还没有结束，pthread_join会一直阻塞在这里
    int * thread_retval;
    ret = pthread_join(tid,(void **)&thread_retval);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error : %s\n",errstr);
    }else {
        printf("success\n");
    }

    printf("exit data : %d\n",*thread_retval);

    //让主线程退出，当主线程退出时，不会影响其他正常运行的线程
    pthread_exit(NULL);


    return 0;

}

在这里插入图片描述

5 线程的分离

/*
    #include<pthread.h>
    int pthread_detach(pthread_t thread);
        功能：分离一个线程。被分离的线程在终止的时候，会自动释放资源返回给系统。
        1、不能多次分离，会产生不可预料的行为。
        2、不能去连接一个已经分离的线程，否则会报错。
        
        参数：需要分离的线程的ID
        返回值：成功0
                失败：返回错误号

*/
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<unistd.h>
#include<stdio.h>

void *callback(void *arg){
    printf("child thread : %ld",pthread_self());
    return NULL;
}

int main(){

    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error data : %s \n",errstr);
    }

    //输出主线程和子线程的ID
    printf("parent thread : %ld , child tread : %ld \n",pthread_self(),tid);

    //设置子线程分离，子线程分离后，子线程结束时对应的资源就不需要主线程释放
    pthread_detach(tid);

    //退出主线程，对子线程没有影响
    pthread_exit(NULL);

    return 0;
}

6 线程取消

/*
    #include<pthread.h>
    int pthread_cancel(pthread_t thread);
        功能：取消线程（让线程终止）
              取消某个线程，可以终止某个线程的运行，
              但是并不是立马终止，而是当子线程执行到一个取消点，线程才会终止。
              取消点：系统规定好的一些系统调用，我们可以粗略的理解为用户区到内核区的切换，这个位置称为取消点。

*/
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<unistd.h>
#include<stdio.h>

void *callback(void *arg){
    printf("child thread : %ld\n",pthread_self());

    for(int i = 0; i< 5; i++){
        printf("child : %d\n",i);
    }
    return NULL;
}

int main(){

    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error data : %s \n",errstr);
    }

    // 取消线程
    pthread_cancel(tid);

    
    for(int i = 0; i< 5; i++){
        printf("%d\n",i);
    }

    //输出主线程和子线程的ID
    printf("parent thread : %ld , child tread : %ld \n",pthread_self(),tid);

    //退出主线程，对子线程没有影响
    pthread_exit(NULL);

    return 0;
}

程序运行多次发现运行结果并不相同，这说明pthread_cancel取消一个线程并不是立马终止，而是到达一个取消点之后才会终止

7 线程属性

在这里插入图片描述

跟属性相关的线程的一些函数 （按两次tab键）
在这里插入图片描述

/*
    int pthread_attr_init(pthread_attr_t *attr);
        - 初始化线程属性变量

    int pthread_attr_destroy(pthread_attr_t *attr);
        - 释放线程属性的资源

    int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
        - 获取线程分离的状态属性

    int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
        - 设置线程分离的状态属性
*/    
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<unistd.h>
#include<stdio.h>

void *callback(void *arg){
    printf("child thread : %ld\n",pthread_self());
    return NULL;
}

int main(){

    //创建一个线程属性变量
    pthread_attr_t attr;
    //初始化属性变量
    pthread_attr_init(&attr);
    //设置属性
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

    

    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid,&attr,callback,NULL);
    if(ret != 0){
        char *errstr = strerror(ret);
        printf("error data : %s \n",errstr);
    }

    //获取线程的栈的大小
    size_t size;
    pthread_attr_getstacksize(&attr,&size);

    printf("thread satck size : %ld \n",size);
    

    //输出主线程和子线程的ID
    printf("parent thread : %ld , child tread : %ld \n",pthread_self(),tid);

    

    //释放线程属性资源
    pthread_attr_destroy(&attr);

    //退出主线程，对子线程没有影响
    pthread_exit(NULL);

    return 0;
}

8 线程同步

/*
    使用多线程实现买票的案例
    有3个窗口，一共是100张票

*/

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

//门票不能放到sellticket函数里面，不然三个子线程都会卖100张，不合题意，一共就100张
static int tickets = 100;

void * selltickets(void *arg){

    //卖票
    
    while(tickets > 0){
        //睡眠多少微秒
        usleep(3000);
        printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
        tickets --;
    }

}
int main(){

    //创建3个子线程
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,selltickets,NULL);
    pthread_create(&tid2,NULL,selltickets,NULL);
    pthread_create(&tid3,NULL,selltickets,NULL);


    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);

    //回收子线程资源和设置线程分离 二选一

    //设置线程分离
    // pthread_detach(tid1);
    // pthread_detach(tid2);
    // pthread_detach(tid3);


    //退出主线程
    pthread_exit(NULL);//不影响子线程

    return 0;
}

卖票案例遇到的问题
在这里插入图片描述

解决办法：线程同步
在这里插入图片描述

9 互斥锁

实现线程同步的手段：互斥量（互斥锁）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
使用互斥量给某共享资源加锁

/*
    互斥量的类型 pthread_mutex_t
    int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
        - 初始化互斥量
        - 参数 ：
            - mutex ： 需要初始化的互斥量变量
            - attr ： 互斥量相关的属性，NULL
        - restrict : C语言的修饰符，被修饰的指针，不能由另外的一个指针进行操作。
            pthread_mutex_t *restrict mutex = xxx;
            pthread_mutex_t * mutex1 = mutex; //报错

    int pthread_mutex_destroy(pthread_mutex_t *mutex);
        - 释放互斥量的资源

    int pthread_mutex_lock(pthread_mutex_t *mutex);
        - 加锁，阻塞的，如果有一个线程加锁了，那么其他的线程只能阻塞等待

    int pthread_mutex_trylock(pthread_mutex_t *mutex);
        - 尝试加锁，如果加锁失败，不会阻塞，会直接返回。

    int pthread_mutex_unlock(pthread_mutex_t *mutex);
        - 解锁
*/
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>


//门票不能放到sellticket函数里面，不然三个子线程都会卖100张，不合题意，一共就100张
static int tickets = 1000;

//创建一个互斥量
pthread_mutex_t mutex;

void * selltickets(void *arg){

    //加锁
    //pthread_mutex_lock(&mutex);

    //卖票 这样不行，虽然数据没有问题，但是都是一个线程卖的
    // while(tickets > 0){
    //     //睡眠多少微秒
    //     usleep(3000);
    //     printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
    //     tickets --;
    // }

    //改进
    while(1){
        //加锁
        pthread_mutex_lock(&mutex);

        if(tickets>0){
            usleep(8000);
            printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
            tickets --;
        }else{
            //解锁
            pthread_mutex_unlock(&mutex);
            break;
        }

        //解锁
        pthread_mutex_unlock(&mutex);

    }

    //解锁
    //pthread_mutex_unlock(&mutex);
}

int main(){

    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);

    //创建3个子线程
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,selltickets,NULL);
    pthread_create(&tid2,NULL,selltickets,NULL);
    pthread_create(&tid3,NULL,selltickets,NULL);


    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);

    //回收子线程资源和设置线程分离 二选一

    //设置线程分离
    // pthread_detach(tid1);
    // pthread_detach(tid2);
    // pthread_detach(tid3);


    //退出主线程
    pthread_exit(NULL);//不影响子线程

    //释放互斥量的资源
    pthread_mutex_destroy(&mutex);

    return 0;
}

10 死锁

在这里插入图片描述
第一种情况，忘记释放锁，可以发现程序执行的时候阻塞了，除了第一个进程其他进程都被阻塞进不去。
在这里插入图片描述
在这里插入图片描述

第二种情况，重复加锁，第一个线程被阻塞在第二个锁外面，其他线程被阻塞在第一个锁外面（所有线程都被阻塞）
在这里插入图片描述
在这里插入图片描述
第三种情况多线程多锁，抢占锁资源。两个线程，其中一个线程执行worka，另外一个执行workb，当worka给mutex1加锁后，休眠一秒，与此同时，第二个函数，workb给mutex2加锁，休眠一秒，worka再给mutex2加锁，发现2被其他线程（b)加锁了，a不能给他加锁了，b想给mutex1加锁发现也不行，就这样陷入了僵局。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

所以我们在使用互斥量的时候，要避免产生死锁。

11 读写锁

在这里插入图片描述
在这里插入图片描述

读写锁：读的时候可以多个线程同时读，但是如果有线程进行写操作，则其他线程的读，写要停止
在这里插入图片描述

/*
    读写锁的类型 pthread_rwlock_t
    int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
    int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
    int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
    int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

    案例：8个线程操作同一个全局变量。
    3个线程不定时写这个全局变量，5个线程不定时的读这个全局变量
*/
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

//创建一个共享数据
int num = 1;

//互斥锁
pthread_mutex_t mutex;
//读写锁
pthread_rwlock_t rwlock;

void *writeNum(void * arg){
    while(1){
        //pthread_mutex_lock(&mutex);
        pthread_rwlock_wrlock(&rwlock);
        num++;
        printf("----write,tid : %ld, num : %d \n",pthread_self(),num);
        //pthread_mutex_unlock(&mutex);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }

}
void *readNum(void * arg){
    while(1){
        //pthread_mutex_lock(&mutex);
        pthread_rwlock_rdlock(&rwlock);
        printf("+++++read, tid : %ld, num : %d\n",pthread_self(),num);
        //pthread_mutex_unlock(&mutex);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }
    
}

int main(){

    //pthread_mutex_init(&mutex,NULL);
    pthread_rwlock_init(&rwlock,NULL);

    //创建3个写线程，5个读线程
    pthread_t wtids[3],rtids[5];
    for(int i=0;i<3;++i){
        pthread_create(&wtids[i],NULL,writeNum,NULL);
    }
    for(int i=0;i<5;++i){
        pthread_create(&rtids[i],NULL,readNum,NULL);
    }


    //设置线程分离
    for(int i=0;i<3;++i){
        pthread_detach(wtids[i]);
    }
    for(int i=0;i<5;++i){
        pthread_detach(rtids[i]);
    }

    //pthread_mutex_destroy(&mutex);
    pthread_rwlock_destroy(&rwlock);

    //退出主线程
    pthread_exit(NULL);

    return 0;

}

在这里插入图片描述

12 生产者和消费者模型

在这里插入图片描述
生产者消费者粗略版本（有错误，未改，下面的视频里面会改）

/*
    生产者消费者模型（粗略的版本）
*/

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

struct Node{
    int num;
    struct Node *next;
};
//头结点
struct Node *head = NULL;

void *producer(void *arg){
    //不断创建新的结点，添加到链表中（生产者）
    while(1){
        struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));

        newNode->next = head;
        head = newNode;
        newNode->num = rand()%1000;
        printf("add node , num : %d ,tid : %ld\n",newNode->num,pthread_self());
        usleep(100);
    }
    return NULL;

}
void *customer(void *arg){
    while(1){
        //保存头结点的指针
        struct Node *temp = head;
        head = head->next;
        printf("del node , num : %d ,tid : %ld\n",temp->num,pthread_self());
        free(temp);
        usleep(100);
    }
}

int main(){

    //创建5个生产者线程， 5个消费者线程
    pthread_t ptids[5],ctids[5];

    for(int i=0; i<5; ++i){
        pthread_create(&ptids[i],NULL,producer,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }

    //线程分离
    for(int i=0;i<5;++i){
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    
    //线程退出，退出主线程，就不会执行return 0？
    pthread_exit(NULL);

    return 0;
}

13 条件变量

在这里插入图片描述
条件变量不是锁，不能解决数据混乱的问题。是配合互斥锁或者读写锁使用的。

/*
    条件变量的类型 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);
    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, const struct timespec *restrict abstime);
        - 等待多长时间，调用了这个函数，线程会阻塞，直到指定的时间结束。
    int pthread_cond_signal(pthread_cond_t *cond);
        - 唤醒一个或者多个等待的线程
    int pthread_cond_broadcast(pthread_cond_t *cond);
        - 唤醒所有的等待的线程
*/
/*
    生产者消费者模型（粗略的版本）
*/

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

//创建一个互斥量解决数据不同步问题
pthread_mutex_t mutex;
//创建条件变量
pthread_cond_t cond;

struct Node{
    int num;
    struct Node *next;
};
//头结点
struct Node *head = NULL;

void *producer(void *arg){
    //不断创建新的结点，添加到链表中（生产者）
    while(1){

        pthread_mutex_lock(&mutex);
        struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));

        newNode->next = head;
        head = newNode;
        newNode->num = rand()%1000;
        printf("add node , num : %d ,tid : %ld\n",newNode->num,pthread_self());

        //只要生产了一个，就通知消费者
        pthread_cond_signal(&cond);

        pthread_mutex_unlock(&mutex);
        usleep(100);
    }
    return NULL;

}
void *customer(void *arg){
    while(1){
        pthread_mutex_lock(&mutex);
        //保存头结点的指针
        struct Node *temp = head; 

        //判断是否有数据
        if(head != NULL){
            head = head->next;
            printf("del node , num : %d ,tid : %ld\n",temp->num,pthread_self());
            free(temp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        }else{
            //没有数据，需要等待
            //当生产者执行了pthread_cond_signal，wait就会被唤醒
            // 当wait这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞时，继续向下执行，会重新加锁
            pthread_cond_wait(&cond,&mutex);
            pthread_mutex_unlock(&mutex);
        }
        
    }
}

int main(){

    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);

    //创建5个生产者线程， 5个消费者线程
    pthread_t ptids[5],ctids[5];

    for(int i=0; i<5; ++i){
        pthread_create(&ptids[i],NULL,producer,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }

    //线程分离
    for(int i=0;i<5;++i){
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1){
        sleep(10);
    }
    //destroy写在exit后面会不执行，写在前面，线程分离之后就销毁，没有意义，解决办法写一个for循环让他睡眠
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    
    //线程退出，退出主线程，就不会执行return 0？
    pthread_exit(NULL);

    

    return 0;
}

生产者消费者遇到的问题在这边得以解决

14 信号量

信号量（信号灯）做的事情与条件变量类似，都是用来阻塞线程。
信号灯，顾名思义，灯一共有两种状态，灯亮表明资源可用，灯灭表明资源不可用。

在这里插入图片描述
使用信号量实现生产者和消费者模型

/*
    信号量的类型 sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - sem : 信号量变量的地址
            - pshared : 0 用在线程间 ，非0 用在进程间
            - value : 信号量中的值

    int sem_destroy(sem_t *sem);
        - 释放资源

    int sem_wait(sem_t *sem);
        - 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞

    int sem_trywait(sem_t *sem);

    int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
    int sem_post(sem_t *sem);
        - 对信号量解锁，调用一次对信号量的值+1

    int sem_getvalue(sem_t *sem, int *sval);

    sem_t psem;
    sem_t csem;
    init(psem, 0, 8);
    init(csem, 0, 0);

    producer() {
        sem_wait(&psem);
        sem_post(&csem)
    }

    customer() {
        sem_wait(&csem);
        sem_post(&psem)
    }

*/
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
//创建一个互斥量解决数据不同步问题
pthread_mutex_t mutex;
//创建信号量
sem_t psem,csem;

struct Node{
    int num;
    struct Node *next;
};
//头结点
struct Node *head = NULL;

void *producer(void *arg){
    //不断创建新的结点，添加到链表中（生产者）
    while(1){
        sem_wait(&psem);//调用一次，psem值会减一
        pthread_mutex_lock(&mutex);
        struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));

        newNode->next = head;
        head = newNode;
        newNode->num = rand()%1000;
        printf("add node , num : %d ,tid : %ld\n",newNode->num,pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);//调用一次，csem值会加一
        usleep(100);
    }
    return NULL;

}
void *customer(void *arg){
    while(1){
        sem_wait(&csem);//生产者生产之后，上面的sem_post会给csem加一，表明容器里面有一个数据，wait调用之后会减一，表示消费一个数据
        pthread_mutex_lock(&mutex);
        //保存头结点的指针
        struct Node *temp = head; 
        head = head->next;
        printf("del node , num : %d ,tid : %ld\n",temp->num,pthread_self());
        free(temp);
        pthread_mutex_unlock(&mutex);
        sem_post(&psem);//对生产者信号量的值加一
        usleep(100);
        
        
    }
}

int main(){

    pthread_mutex_init(&mutex,NULL);
    sem_init(&psem,0,8);
    sem_init(&csem,0,0);

    //创建5个生产者线程， 5个消费者线程
    pthread_t ptids[5],ctids[5];

    for(int i=0; i<5; ++i){
        pthread_create(&ptids[i],NULL,producer,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }

    //线程分离
    for(int i=0;i<5;++i){
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1){
        sleep(10);
    }
    //destroy写在exit后面会不执行，写在前面，线程分离之后就销毁，没有意义，解决办法写一个for循环让他睡眠
    pthread_mutex_destroy(&mutex);

    sem_destroy(&csem);
    sem_destroy(&psem);
    
    //线程退出，退出主线程，就不会执行return 0？
    pthread_exit(NULL);

    

    return 0;
}
一直特立独行的橙
关注
嵌入式软件开发技术：第5章 嵌入式Linux多线程编程.ppt
05-31
嵌入式Linux多线程编程是嵌入式系统开发中的一种重要技术，能够提高系统的效率和响应速度。本章节将详细介绍嵌入式Linux多线程编程的基本概念、线程的创建、同步和互斥、线程属性、多线程实验等方面的知识点。 1. ...
嵌入式操作系统：第9章 嵌入式Linux多线程开发.ppt
05-31
在Linux中，多线程开发主要依赖于POSIX线程库（Pthread），该库提供了丰富的API来支持线程的创建、管理和同步。以下是一些关键的线程操作： 1. **线程创建**：使用`pthread_create()`函数创建新的线程，该函数需要...
7、Linux多线程开发
chenyfan_blog
06-14 793
Linux高并发服务器开发--牛客网课程
第3章 Linux多线程开发 08线程同步
IS_MOKE的博客
11-09 129
01 / 线程同步 02 / 互斥量 03 / 互斥量相关操作函数 04 / 死锁 05 / 读写锁 06 / 读写锁相关操作函数 07 / 生产者消费者模型 08 / 条件变量 09 / 信号量
第3章 Linux多线程开发 01线程
IS_MOKE的博客
11-08 203
01 / 线程概述 02 / 线程和进程区别 03 / 线程和进程虚拟地址空间 04 / 线程之间共享和非共享资源 05 / NPTL 06 / 线程操作 07 / 线程属性
Linux 多线程开发
weixin_43412762的博客
03-11 1753
Linux 多线程开发 3.1 线程 3.1.2 线程操作 3.1.2 线程属性 3.2 线程同步 3.2.1 互斥量/锁 3.2.2 死锁 3.2.3 读写锁 3.3 生产者消费者模型 3.3.1 条件变量 3.3.2 信号量/灯
Linux 多线程开发（附有案例代码）
热爱数据库的小胖
07-15 5798
同一个程序中的所有线程均会独立执行相同程序，且共享同一份全局内存区域，其中包括初始化数据段、未初始化数据段，以及堆内存段。(传统意义上的UNIX进程只是多线程程序的一个特例,该进程只包含一个线程)调用fork()来创建进程的代价相对较高，即便利用写时复制技术，仍热需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork()调用在时间上的开销依然不菲。进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。进程ID和父进程工D。..
Linux多线程开发
qq_41511474的博客
04-18 1173
在主线程中，在创建子线程前设置子线程为分离属性，pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)，或者主线程调用detach()函数分离子线程，子线程退出时，系统将自动回收资源。功能：让线程终止，取消某个线程可以终止某个线程运行，但是不是立马终止，而是当子线程执行到一个取消点，线程才会终止（取消点：系统规定的系统调用，粗略理解为从用户区到内核区的系统切换的点）。只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。
Linux多线程
m0_56821563的博客
04-15 911
本篇博客主要讲述了线程概念和线程控制两方面内容。
Linux多线程机制
weixin_49376454的博客
05-21 1618
Linux多线程机制Linux多线程机制Linux多线程机制Linux多线程机制
Linux多线程编程
C_Trip的博客
11-19 3844
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux下的systemd/service
最新发布
zxz_Fine的博客
11-05 282
开机自启任务
Linux：网络协议socket
Au_ust的博客
11-05 733
我们之前学的通信是本地进程间通信，如果我们想在网络间通信的话，就需要用到二者的ip地址，分别被称为源IP地址和目的IP地址，被存入ip数据包中，其次我们还需要遵循一些通信协议。TCP协议：传输层协议，有连接，可靠传输，面向字节流（无明确边界的字节序列），难UDP协议：传输层协议，无连接，不可靠传输，面向数据流（以数据包为单位），简单网络通信的本质也是进程间通信，你怎么知道你要和哪个进程通信？
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
m0_73093743的博客
11-02 445
只能建立一个对象的设计模式。
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 689
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux——Linux基础指令
辰多代码的博客
11-05 464
比 more 更强大的分页器，支持前后翻页和搜索。1：移动文件或目录（前提是目标文件或目录不存在）。：重命名文件或目录（前提是目标文件或目录存在）。:：显示系统上当前登录的用户及其相关信息。：显示网络连接、路由表和网络接口统计信息。：统计文件的行数、字数和字节数。：显示当前工作目录的完整路径。：列出目录中的文件和子目录。：显示或设置系统日期和时间。：在目录层次结构中搜索文件。：显示系统中正在运行的进程。：配置或显示网络接口信息。：显示当前用户的用户名。：更新现有文件的时间戳。：查找可执行文件的位置。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 687
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
『 Linux 』网络传输层 - TCP(二)
小侯宝的博客
11-01 959
为什么是三次握手三次握手是TCP为了保证双方通信时具有可靠性所定制的一种策略;而三次握手可以确保客户端和服务端至少都向对方发送了一次消息,从而确保连接建立的更为可靠;以朴素的角度来看三次握手实际上也可以被解析成四次握手;但为了提升连接创建的效率,TCP采用捎带应答的策略,在第二次握手中将ACK报文与SYN报文整合成了一个报文,即为SYN+ACK报文;在三次握手中能够确保双端都对对方进行一次消息的发送以及消息的接收来确保连接的稳定,因此三次握手中任何一次握手都不能少;
【Linux】信号三部曲——产生、保存、处理
m0_74808907的博客
11-02 2509
一文带你由浅入深掌握信号产生、保存、处理！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值