day05-进程通信

1> 将互斥机制的代码实现重新敲一遍

代码：

#include<myhead.h>

int num=520;//临界资源

//1.创建互斥锁
pthread_mutex_t fastmutex;
       
//定义任务函数
void *task1(void *arg){
    printf("1111111\n");

    //3.临界区上面获取锁资源（上锁）
    pthread_mutex_lock(&fastmutex);

    num=1314;
    sleep(3);
    printf("task1:num = %d\n",num); //1314

    //4. 释放锁资源
    pthread_mutex_unlock(&fastmutex);
}

void *task2(void *arg){
    printf("2222222\n");

    pthread_mutex_lock(&fastmutex);

    num++;      //521
    sleep(1);   //休眠时任务1执行到赋值语句
    printf("task2:num = %d\n",num);

    pthread_mutex_unlock(&fastmutex);
}

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

    //2.初始化互斥锁
    pthread_mutex_init(&fastmutex,NULL);

    //线程创建
    pthread_t tid1,tid2;
    if(pthread_create(&tid1,NULL,task1,NULL)!=0){
        printf("tid1 create error\n");
        return 0;
    }

    if(pthread_create(&tid2,NULL,task2,NULL)!=0){
        printf("tid2 create error\n");
        return 0;
    }

    printf("tid1:%#lx, tid2:%#lx\n",tid1,tid2);

    //回收资源
    if(pthread_join(tid1,NULL)==0)
        printf("tid1回收成功\n");
    if(pthread_join(tid2,NULL)==0)
        printf("tid2回收成功\n");

    //5. 销毁锁资源
    pthread_mutex_destroy(&fastmutex);
    
    return 0;
}

结果：

2> 将无名信号量的代码实现重新敲一遍

代码：

#include<myhead.h>

//创建无名信号了
sem_t sem;

//定义生产者线程
void *task1(void *arg){
    printf("1111111\n");
    
    int num= 5;
    while(num--){
        //3.申请资源
    //    sem_wait(&sem);

        sleep(1);
        printf("我生产了一辆车\n");

        //4.释放资源
        sem_post(&sem);

    }
    pthread_exit(NULL);
}

//定义消费者线程
void *task2(void *arg){
    printf("2222222\n");

    int num= 5;
    while(num--){
        //3.申请资源
        sem_wait(&sem);

        printf("我消费了一辆车\n");

         //4.释放资源
    //    sem_post(&sem);
    }
    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    //初始化无名信号量
    sem_init(&sem,0,0);
    //第一个0:表示用于线程的同步
    //第二个0:表示初始资源为0
    
    //创建两个线程，分别是生产者和消费者
    pthread_t tid1,tid2;
    if(pthread_create(&tid1,NULL,task1,NULL)!=0){
        printf("tid1 create error\n");
        return 0;
    }

    if(pthread_create(&tid2,NULL,task2,NULL)!=0){
        printf("tid2 create error\n");
        return 0;
    }

    printf("tid1:%#lx, tid2:%#lx\n",tid1,tid2);

    //回收资源
    if(pthread_join(tid1,NULL)==0)
        printf("tid1回收成功\n");
    if(pthread_join(tid2,NULL)==0)
        printf("tid2回收成功\n");

    //释放无名信号量
    sem_destroy(&sem);

    return 0;
}

结果：

3> 将条件变量的代码实现重新敲一遍

代码：

#include<myhead.h>

//1. 定义条件变量
pthread_cond_t cond;

//11. 创建互斥锁
pthread_mutex_t fastmutex;

//定义生产者线程
void *task1(void *arg){

    int num= 5;
    while(num--){

        sleep(1);
        printf("%#lx:生产了一辆车\n",pthread_self());

        //3. 唤醒一个消费者
        pthread_cond_signal(&cond);
    }
    pthread_exit(NULL);
}

//定义消费者线程
void *task2(void *arg){

    //33.临界区上面获取锁资源（上锁）
    pthread_mutex_lock(&fastmutex);

    //4. 进入等待队列
    pthread_cond_wait(&cond,&fastmutex);


    printf("%#lx:消费了一辆车\n",pthread_self());

    //54. 释放锁资源
    pthread_mutex_unlock(&fastmutex);

    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    //2. 初始化无名信号量
    pthread_cond_init(&cond,NULL);
    
    //22. 初始化互斥锁
    pthread_mutex_init(&fastmutex,NULL);

    //创建2个线程，分别是生产者和消费者
    pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
    if(pthread_create(&tid1,NULL,task1,NULL)!=0){
        printf("tid1 create error\n");
        return 0;
    }
    if(pthread_create(&tid2,NULL,task2,NULL)!=0){
        printf("tid2 create error\n");
        return 0;
    }
        if(pthread_create(&tid3,NULL,task2,NULL)!=0){
        printf("tid3 create error\n");
        return 0;
    }
    if(pthread_create(&tid4,NULL,task2,NULL)!=0){
        printf("tid4 create error\n");
        return 0;
    }    
    if(pthread_create(&tid5,NULL,task2,NULL)!=0){
        printf("tid5 create error\n");
        return 0;
    }
    if(pthread_create(&tid6,NULL,task2,NULL)!=0){
        printf("tid6 create error\n");
        return 0;
    }
    printf("tid1:%#lx, tid2:%#lx, tid3:%#lx\ntid4:%#lx, tid5:%#lx, tid6:%#lx\n",tid1,tid2,tid3,tid4,tid5,tid6);

    //回收资源
    if(pthread_join(tid1,NULL)==0)
        printf("tid1回收成功\n");
    if(pthread_join(tid2,NULL)==0)
        printf("tid2回收成功\n");
    if(pthread_join(tid3,NULL)==0)
        printf("tid3回收成功\n");
    if(pthread_join(tid4,NULL)==0)
        printf("tid4回收成功\n");
    if(pthread_join(tid5,NULL)==0)
        printf("tid5回收成功\n");
    if(pthread_join(tid6,NULL)==0)
        printf("tid6回收成功\n");


    //5. 销毁条件变量
    pthread_cond_destroy(&cond);

    //55. 销毁锁资源
    pthread_mutex_destroy(&fastmutex);
    return 0;
}

结果：

4> 将无名管道的代码实现重新敲一遍

代码：

#include<myhead.h>

int main(int argc, char const *argv[])
{
    //创建管道文件，并返回该管道文件的文件描述符（最小位分配原则）
    int pipefd[2]={0};
    if(pipe(pipefd)==1)
        PRINT_ERR("");
    printf("pipedf[0]=%d,pipefd[1]=%d\n",pipefd[0],pipefd[1]);

    //创建一个子进程
    pid_t pid=fork();

    if(pid>0){
        //父进程

        //关闭管道的读端
        close(pipefd[0]);

        char wbuf[128]="";
        while(1)
        {
            bzero(wbuf,sizeof(wbuf));   //清空数组内容

            fgets(wbuf,sizeof(wbuf),stdin);     //从终端输入数据
            wbuf[strlen(wbuf)-1]=0;

            //将数据写入管道文件中
            write(pipefd[1],wbuf,strlen(wbuf));

            //对写入的数据进行判断
            if(strcmp(wbuf,"quit")==0)
                break;
        }

        //关闭写端
        close(pipefd[1]);

        wait(NULL);  //阻塞回收子进程资源
    }else if(pid==0){
        //子进程
        //关闭写端
        close(pipefd[1]);

        char rbuf[128]="";
        while(1)
        {
            //清空rbuf内容
            bzero(rbuf,sizeof(rbuf));

            //从管道文件中读取数据
            read(pipefd[0],rbuf,sizeof(rbuf));

            //输出rbuf的数据
            printf("父进程传来的数据为:%s\n",rbuf);

            //对读取的数据进行判断
            if(strcmp(rbuf,"quit")==0)
                break;
        }

        //关闭管道的读端
        close(pipefd[0]);

        exit(EXIT_SUCCESS);     //退出进程
    }else
        PRINT_ERR("");    
    return 0;
}

结果：

5> 将有名管道的代码实现重新敲一遍

代码：

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //创建一个管道文件
    if(mkfifo("./myfifo", 0664) == -1)
    {
        perror("mkfifo error");
        return -1;
    }

    getchar();       //阻塞

    system("rm myfifo");

    return 0;
}
#include<myhead.h>

int main(int argc, char const *argv[])
{
    //打开管道文件
    int wfd=1;

    //以只写的形式打开文件
    if((wfd=open("./myfifo",O_WRONLY))==-1)
        PRINT_ERR("");

    //定义容器
    char wbuf[128]="";
    while(1)
    {
        bzero(wbuf,sizeof(wbuf));   //清空数组内容
        
        fgets(wbuf,sizeof(wbuf),stdin);     //从终端输入数据
        wbuf[strlen(wbuf)-1]=0;

            //将数据写入管道文件中
         write(wfd,wbuf,strlen(wbuf));

            //对写入的数据进行判断
            if(strcmp(wbuf,"quit")==0)
                break;
    }
    return 0;
}

#include<myhead.h>

int main(int argc, char const *argv[])
{
    //打开管道文件
    int wfd=1;

    //以只读的形式打开文件
    if((wfd=open("./myfifo",O_RDONLY))==-1)
        PRINT_ERR("");

    //定义容器
    char rbuf[128]="";
    while(1)
    {
        
        //清空rbuf内容
        bzero(rbuf,sizeof(rbuf));
    
        //将数据写入管道文件中
        read(wfd,rbuf,sizeof(rbuf));

        //输出rbuf的数据
        printf("父进程传来的数据为:%s\n",rbuf);

        //对读取的数据进行判断
        if(strcmp(rbuf,"quit")==0)
            break;
    }
    return 0;
}

结果：

6> 使用有名管道完成两个进程的相互通信(提示：可以使用多进程或多线程完成)

代码：

管道文件创建

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //创建一个管道文件
    if(mkfifo("./myfifo1", 0664) == -1)
    {
        perror("mkfifo1 error");
        return -1;
    }
    if(mkfifo("./myfifo2", 0664) == -1)
    {
        perror("mkfifo2 error");
        return -1;
    }
    getchar();       //阻塞

    system("rm myfifo1");
    system("rm myfifo2");

    return 0;
}

线程：

#include<myhead.h>

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


    //创建一个子进程
    pid_t pid=fork();

    if(pid>0){
        //父进程

        //打开管道文件
        int wfd = -1;
        //以只写的形式打开文件
        if((wfd = open("./myfifo1", O_WRONLY)) == -1)
        {
            perror("open error");
            return -1;
        }

        //定义容器
        char wbuf[128] = "";


       
        while(1)
        {

                printf("这里是1号机,请输入>>>");
                fgets(wbuf, sizeof(wbuf), stdin);
                wbuf[strlen(wbuf)-1] = 0;

                //将数据写入有名管道
                write(wfd, wbuf, strlen(wbuf));

                //判断结果
                if(strcmp(wbuf,"quit") == 0)
                    break;

        }
            //关闭文件
        close(wfd);          
//        wait(NULL);  //阻塞回收子进程资源
    }else if(pid==0){
        //子进程
        //打开管道文件
        int rfd = -1;
    //以只写读的形式打开文件
        if((rfd = open("./myfifo2", O_RDONLY)) == -1)
        {
            perror("open error");
            return -1;
        }

        //定义容器
        char rbuf[128] = "";
        while(1)
        {
            //清空数组
            bzero(rbuf, sizeof(rbuf));
        
            //读取管道中的数据
            read(rfd, rbuf, sizeof(rbuf));

            //输出结果
            printf("\t\t\t\t\t1号机收到的数据为：%s\n", rbuf);

            //判断结果
            if(strcmp(rbuf,"quit") == 0)
                break;

    }

            //关闭文件
            close(rfd);

        exit(EXIT_SUCCESS);     //退出进程
    }else
        PRINT_ERR("");    
    return 0;
}

#include<myhead.h>

int main(int argc, char const *argv[])
{
    //创建一个子进程
    pid_t pid=fork();

    if(pid>0){
        //父进程
       //打开管道文件
        int rfd = -1;
    //以只写读的形式打开文件
        if((rfd = open("./myfifo1", O_RDONLY)) == -1)
        {
            perror("open error");
            return -1;
        }

        //定义容器
        char rbuf[128] = "";
        while(1)
        {
            //清空数组
            bzero(rbuf, sizeof(rbuf));
        
            //读取管道中的数据
            read(rfd, rbuf, sizeof(rbuf));

            //输出结果
            printf("\t\t\t\t\t2号机收到的数据为：%s\n", rbuf);

            //判断结果
            if(strcmp(rbuf,"quit") == 0)
                break;


    }

            //关闭文件
        close(rfd); 
 
 //       wait(NULL);
     //   wait(NULL);  //阻塞回收子进程资源
    }else if(pid==0){
        //子进程
        //打开管道文件
        int wfd = -1;
        //以只写的形式打开文件
        if((wfd = open("./myfifo2", O_WRONLY)) == -1)
        {
            perror("open error");
            return -1;
        }

        //定义容器
        char wbuf[128] = "";


        while(1)
        {


                printf("这里是2号机,请输入>>>");
                fgets(wbuf, sizeof(wbuf), stdin);
                wbuf[strlen(wbuf)-1] = 0;

                //将数据写入管道
                write(wfd, wbuf, strlen(wbuf));

                //判断结果
                if(strcmp(wbuf,"quit") == 0)
                    break;
            
        }

            //关闭文件
        close(wfd);      

        exit(EXIT_SUCCESS);     //退出进程
    }else
        PRINT_ERR("");    
    return 0;
}

结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/402681.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

开发个IDEA插件

开发个IDEA插件

开发IDEA一个插件&#xff0c;但是这个插件的功能是个大杂烩吧&#xff0c; 主要完成以下几个功能&#xff0c;方便组内开发人员提高效率。 1 网关会传过来登录人员的 一些核心字段&#xff0c;公司编码/用户编号/主岗。 因为存在多租户&#xff0c;所以经常要切换任务&…
阅读更多...
【ACM出版】第五届计算机信息和大数据应用国际学术会议（CIBDA 2024）

【ACM出版】第五届计算机信息和大数据应用国际学术会议（CIBDA 2024）

第五届计算机信息和大数据应用国际学术会议&#xff08;CIBDA 2024&#xff09; 2024 5th International Conference on Computer Information and Big Data Applications 重要信息 大会官网&#xff1a;www.ic-cibda.org 大会时间&#xff1a;2024年3月22-24日 大会地点&#…
阅读更多...
LeetCode 0106.从中序与后序遍历序列构造二叉树：分治（递归）——五彩斑斓的题解（若不是彩色的可以点击原文链接查看）

LeetCode 0106.从中序与后序遍历序列构造二叉树：分治（递归）——五彩斑斓的题解（若不是彩色的可以点击原文链接查看）

【LetMeFly】106.从中序与后序遍历序列构造二叉树&#xff1a;分治&#xff08;递归&#xff09;——五彩斑斓的题解&#xff08;若不是彩色的可以点击原文链接查看&#xff09; 力扣题目链接&#xff1a;https://leetcode.cn/problems/construct-binary-tree-from-inorder-an…
阅读更多...
开发Chrome插件，background.js中log打印未出现在控制台

开发Chrome插件，background.js中log打印未出现在控制台

不同于内容脚本&#xff08;通常命名content.js&#xff09;&#xff0c;在后台脚本&#xff08;通常命名background.js或service-worker.js&#xff09;中console.log并不会在控制台中直接显示。 要查看后台脚本上下文的正确控制台&#xff0c;执行如下步骤&#xff1a; 访问…
阅读更多...
leetcode hot100单词拆分

leetcode hot100单词拆分

在本题中&#xff0c;我们是要把一个字符串&#xff0c;判断是否能用给的字符串数组中的单词进行拆分&#xff0c;如果可以则返回true&#xff0c;不能的话则返回false。这个题一开始看无法与背包问题联系在一起。但仔细考虑&#xff0c;就是用物品&#xff08;给的字符串数组中…
阅读更多...
在Mac上搭建MongoDB环境

在Mac上搭建MongoDB环境

最近工作中需要装MongoDB环境&#xff0c;搭建过程中遇到了一些问题&#xff0c;在这里记录一下安装MongoDB环境的方法以及问题的解决方法。有两种安装MongoDB的方法&#xff1a;brew安装和手动安装。 目录 使用Homebrew安装MongoDB 手动安装MongoDB&#xff08;不使用Homebr…
阅读更多...
WordPres Bricks Builder 前台RCE漏洞复现(CVE-2024-25600)

WordPres Bricks Builder 前台RCE漏洞复现(CVE-2024-25600)

0x01 产品简介 Bricks Builder是一款用于WordPress的开发主题，提供直观的拖放界面，用于设计和构建WordPress网站。它使用户能够轻松创建自定义的网页布局和设计，无需编写或了解复杂的代码。Bricks Builder具有用户友好的界面和强大的功能，使用户可以通过简单的拖放操作添加…
阅读更多...
Vue图片浏览组件v-viewer，支持旋转、缩放、翻转等操作

Vue图片浏览组件v-viewer，支持旋转、缩放、翻转等操作

Vue图片浏览组件v-viewer&#xff0c;支持旋转、缩放、翻转等操作 之前用过viewer.js&#xff0c;算是市场上用过最全面的图片预览。v-viewer&#xff0c;是基于viewer.js的一个图片浏览的Vue组件&#xff0c;支持旋转、缩放、翻转等操作。 基本使用 安装&#xff1a;npm安装…
阅读更多...
浅谈TCP协议的可靠含义和三次握手

浅谈TCP协议的可靠含义和三次握手

这里不过多阐述计算机网络的体系结构&#xff0c;本文主要是想阐述三次握手和可靠连接之间的联系。TCP协议全称传输控制协议&#xff08;Transmission Cotrol Protocol&#xff09;。 1、TCP协议运行在哪一层 TCP运行在运输层。 2、TCP协议的可靠是什么意思 步入主题&…
阅读更多...
MLflow【部署 01】MLflow官网Quick Start实操（一篇学会部署使用MLflow）

MLflow【部署 01】MLflow官网Quick Start实操（一篇学会部署使用MLflow）

一篇学会部署使用MLflow 1.版本及环境2.官方步骤Step-1 Get MLflowStep-2 Start a Tracking ServerStep 3 - Train a model and prepare metadata for loggingStep 4 - Log the model and its metadata to MLflowStep 5 - Load the model as a Python Function (pyfunc) and us…
阅读更多...
Hackme 1

Hackme 1

信息收集 Nmap部分 存活扫描&#xff1a; └─# nmap -sn 192.168.10.1/24 Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-02-20 15:00 CST Nmap scan report for 192.168.10.1 (192.168.10.1) Host is up (0.00012s latency). MAC Address: 00:50:56:C0:00:08 (VMwar…
阅读更多...
matlab代码--基于matlabLDPC-和积译码系统

matlab代码--基于matlabLDPC-和积译码系统

LDPC编码 一个码长为n、信息位个数为k的线性分组码&#xff08;n,k&#xff09;可以由一个生成矩阵 来定义&#xff0c;信息序列 通过G被映射到码字XS.G。线性分组码也可以由一个校验矩阵 来描述。所以码字均满足 。校验矩阵的每一行表示一个校验约束 &#xff0c;其中所有的非…
阅读更多...
C++入门学习（三十二）二维数组定义方式

C++入门学习（三十二）二维数组定义方式

一维数组类似于一条“线”&#xff0c;而二维数组类似于一个“面”&#xff0c;二维数组也更像一个表格&#xff0c;由我们在“表格”中查询数据。 1、先定义数组&#xff0c;后赋值 int arr[2][3]; #include <iostream> using namespace std;int main() { int arr…
阅读更多...
分类预测 | Matlab实现CWT-DSCNN-MSA基于时序特征、cwt小波时频图的双流卷积融合注意力机制的分类预测

分类预测 | Matlab实现CWT-DSCNN-MSA基于时序特征、cwt小波时频图的双流卷积融合注意力机制的分类预测

分类预测 | Matlab实现CWT-DSCNN-MSA基于时序特征、cwt小波时频图的双流卷积融合注意力机制的分类预测 目录 分类预测 | Matlab实现CWT-DSCNN-MSA基于时序特征、cwt小波时频图的双流卷积融合注意力机制的分类预测分类效果基本描述程序设计参考资料 分类效果 基本描述 1.Matlab…
阅读更多...
day6 2/22

day6 2/22

1> 将互斥机制的代码实现重新敲一遍 #include<myhead.h> int num520; pthread_mutex_t mutex;//创建互斥锁 void*task1(void*arg) {pthread_mutex_lock(&mutex);sleep(3);num;printf("%d\n",num);pthread_mutex_unlock(&mutex);pthread_exit(NULL)…
阅读更多...
2024/2/22

2024/2/22

P8680 [蓝桥杯 2019 省 B] 特别数的和 题目描述 小明对数位中含有 2、0、1、9 的数字很感兴趣&#xff08;不包括前导 00&#xff09;&#xff0c;在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40&#xff0c;共28 个&#xff0c;他们的和是574。 请问&#xff0c;在…
阅读更多...
【Git】：标签功能

【Git】：标签功能

标签功能 一.标签操作二.推送远程标签 标签 tag &#xff0c;可以简单的理解为是对某次commit的⼀个标识&#xff0c;相当于起了⼀个别名。例如&#xff0c;在项⽬发布某个版本的时候&#xff0c;针对最后⼀次commit起⼀个v1.0这样的标签来标识⾥程碑的意义。这有什么⽤呢&…
阅读更多...
CRF算法(Conditional Random Fields)揭秘

CRF算法(Conditional Random Fields)揭秘

CRF基本介绍 在机器学习中&#xff0c;建模线性序列结构的方法&#xff0c;除了HMM算法&#xff0c;另一个重要的模型就是CRF。HMM为了降低模型复杂性&#xff0c;对观测变量做了独立假设(即隐状态之间有相关性&#xff0c;而观测变量之间没有相关性)&#xff0c;这在某种程度…
阅读更多...
五种多目标优化算法（MSSA、MOJS、NSWOA、MOPSO、MOAHA）性能对比，包含6种评价指标，9个测试函数（提供MATLAB代码）

五种多目标优化算法（MSSA、MOJS、NSWOA、MOPSO、MOAHA）性能对比，包含6种评价指标，9个测试函数（提供MATLAB代码）

一、5种多目标优化算法简介 1.1MSSA 1.2MOJS 1.3NSWOA 1.4MOPSO 1.5MOAHA 二、5种多目标优化算法性能对比 为了测试5种算法的性能将其求解9个多目标测试函数&#xff08;zdt1、zdt2 、zdt3、 zdt4、 zdt6 、Schaffer、 Kursawe 、Viennet2、 Viennet3&#xff09;&#xff0c…
阅读更多...
C2-1.4（L1,L2）正则化

C2-1.4（L1,L2）正则化

C2-1.4&#xff08;L1,L2&#xff09;正则化 参考书籍 1 正则化的概念 正则化(Regularization) 是机器学习中对原始损失函数引入额外信息&#xff0c;以便防止过拟合和提高模型泛化性能的一类方法的统称。也就是目标函数变成了原始损失函数额外项&#xff0c;常用的额外项一般…
阅读更多...
最新文章

Copyright @ 2022~2023