IO/作业/2024/8/12

最新推荐文章于 2024-09-16 18:31:59 发布

江阿生_

最新推荐文章于 2024-09-16 18:31:59 发布

阅读量155

点赞数 2

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_70715463/article/details/141140001

版权

递归锁

 #include <sys/ipc.h>
 #include <sys/sem.h>
 #include <semaphore.h>
 #include <sys/msg.h>
 #include <sys/shm.h>
 #include <sys/un.h>
 typedef struct sockaddr_in addr_in_t;
 typedef struct sockaddr addr_t;
 typedef struct sockaddr_un addr_un_t;
 //创建一个互斥锁
 pthread_mutex_t m1;
 //线程任务1
 void* task1(void *arg)
 {
     while(1)
     {
     pthread_mutex_lock(&m1);//上锁两次
     pthread_mutex_lock(&m1);
         printf("hello\n");
         sleep(1);
     pthread_mutex_unlock(&m1);
     }
 }
 //线程任务2
 void* task2(void *arg)
 {
     while(1)
     {
     pthread_mutex_lock(&m1);
         printf("world\n");
         sleep(1);
     pthread_mutex_unlock(&m1);
     }
 }
 //验证递归锁
 int main(int argc, const char *argv[])
 {
     //创建互斥锁属性的变量
     pthread_mutexattr_t attr;
     //初始化互斥锁属性变量
     pthread_mutexattr_init(&attr);
     //将互斥锁的属性设置为递归锁
     pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP);
     //初始化互斥锁
     pthread_mutex_init(&m1,&attr);
 
                                                                     
     //创建线程id
     pthread_t id1,id2;
     //创建线程 
     pthread_create(&id1,0,task1,0);
     pthread_create(&id2,0,task2,0);
     pthread_detach(id2);
 
     while(1)
     //回收线程
     pthread_detach(id1);
 
     return 0;
 }

错误检查锁

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

pthread_mutex_t m1;

// 线程任务1
void* task1(void *arg) {
    while (1) {
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m1);
       int a= pthread_mutex_lock(&m1);
       if(a!=0)
       {
        perror("mutex error");
       }
        printf("hello\n");
        sleep(1);
        pthread_mutex_unlock(&m1);
        pthread_mutex_unlock(&m1);
    }
}
                                                                   
// 线程任务2
void* task2(void *arg) {
    while (1) {
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m1);
        int a= pthread_mutex_lock(&m1);
        if(a!=0)
        {
            perror("mutex error");
        }
        printf("world\n");
        sleep(1);
        pthread_mutex_unlock(&m1);
        pthread_mutex_unlock(&m1);
    }
}

int main(int argc, const char *argv[]) {
    pthread_mutexattr_t attr;

    // 初始化互斥锁属性
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
    pthread_mutex_init(&m1, &attr);

    pthread_t id1, id2;

    // 创建线程
    pthread_create(&id1, NULL, task1, NULL);
    pthread_create(&id2, NULL, task2, NULL);

    // 分离线程
    pthread_detach(id1);
    pthread_detach(id2);

    // 等待线程完成
    sleep(10); // 让线程有时间运行

    // 清理资源
    pthread_mutex_destroy(&m1);
    pthread_mutexattr_destroy(&attr);

    return 0;
}

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>
typedef struct sockaddr_in addr_in_t;
typedef struct sockaddr addr_t;
typedef struct sockaddr_un addr_un_t;
//定义全局变量
int apple=0;
int orange=0;

//创建无名信号量和互斥锁
pthread_cond_t t1;
pthread_mutex_t m1;
pthread_cond_t t2;
pthread_mutex_t m2;
//苹果生产者
void* task1(void* arg)
{
    while(1){
    pthread_mutex_lock(&m1);
    apple+=1;
    if(apple>=3)
    {
        pthread_cond_signal(&t1);
    }
    printf("已生产1个苹果,现存苹果数量为:%d\n",apple);
    pthread_mutex_unlock(&m1);
    sleep(1);
    }
}
//橘子生产者
void* task2(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m2);
    orange+=2;
    if(orange>=5)                                                          
    {
        pthread_cond_signal(&t2);
    }
    printf("已生产2个橘子,现存橘子数量为:%d\n",orange);
    pthread_mutex_unlock(&m2);
    sleep(2);
    }
}
//苹果消费者
void* task3(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m1);
    pthread_cond_wait(&t1,&m1);
    apple-=3;
    printf("已消费3个苹果,现存苹果数量为:%d\n",apple);
    pthread_mutex_unlock(&m1);
    }

}
//橘子消费者
void* task4(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m2);
    pthread_cond_wait(&t2,&m2);
    orange-=5;
    printf("已消费5个橘子,现存橘子数量为:%d\n",orange);
    pthread_mutex_unlock(&m2);
    }
}
int main(int argc, const char *argv[])
{
    //初始化无名信号量和互斥锁
    pthread_cond_init(&t1,0);
    pthread_cond_init(&t2,0);
    pthread_mutex_init(&m1,0);
    pthread_mutex_init(&m2,0);
    //创建线程号
    pthread_t id1,id2,id3,id4;
    //创建线程
    pthread_create(&id1,0,task1,0);
    pthread_create(&id2,0,task2,0);
    pthread_create(&id3,0,task3,0);
    pthread_create(&id4,0,task4,0);
    //回收线程
    while(1);
    pthread_detach(id1);
    pthread_detach(id2);
    pthread_detach(id3);
    pthread_detach(id4);


    return 0;
}

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>
typedef struct sockaddr_in addr_in_t;
typedef struct sockaddr addr_t;
typedef struct sockaddr_un addr_un_t;
//定义全局变量
int apple=0;
int orange=0;

//创建无名信号量和互斥锁
pthread_cond_t t1;
pthread_mutex_t m1;
pthread_cond_t t2;
pthread_mutex_t m2;
pthread_mutex_t m3;
//苹果生产者
void* task1(void* arg)
{
    while(1){
    pthread_mutex_lock(&m1);
    pthread_mutex_lock(&m3);
    apple+=1;

    if(apple>=3&&apple<=10)
    {                                                              
        pthread_cond_signal(&t1);
    }
    printf("已生产1个苹果,现存苹果数量为:%d\n",apple);
    pthread_mutex_unlock(&m1);
    pthread_mutex_unlock(&m3);
    sleep(1);
    }
}
//橘子生产者
void* task2(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m2);
    pthread_mutex_lock(&m3);
    orange+=2;
    if(orange>=5&&apple<=20)
    {
        pthread_cond_signal(&t2);
    }
    printf("已生产2个橘子,现存橘子数量为:%d\n",orange);
    pthread_mutex_unlock(&m2);
    pthread_mutex_unlock(&m3);
    sleep(2);
    }
}
//苹果消费者
void* task3(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m1);
    pthread_cond_wait(&t1,&m1);
    apple-=3;
    printf("已消费3个苹果,现存苹果数量为:%d\n",apple);
    pthread_mutex_unlock(&m1);
    }

}
//橘子消费者
void* task4(void* arg)
{
    while(1)
    {
    pthread_mutex_lock(&m2);
    pthread_cond_wait(&t2,&m2);
    orange-=5;
    printf("已消费5个橘子,现存橘子数量为:%d\n",orange);
    pthread_mutex_unlock(&m2);
    }
}
int main(int argc, const char *argv[])
{
    //初始化无名信号量和互斥锁
    pthread_cond_init(&t1,0);
    pthread_cond_init(&t2,0);
    pthread_mutex_init(&m1,0);
    pthread_mutex_init(&m2,0);
    //创建线程号
    pthread_t id1,id2,id3,id4;
    //创建线程
    pthread_create(&id1,0,task1,0);
    pthread_create(&id2,0,task2,0);
    pthread_create(&id3,0,task3,0);
    pthread_create(&id4,0,task4,0);
    //回收线程
    while(1);
    pthread_detach(id1);
    pthread_detach(id2);
    pthread_detach(id3);
    pthread_detach(id4);


    return 0;
}