IO进程_day7（完结）

已于 2024-10-25 12:30:06 修改
阅读量1k 收藏 23
点赞数 18
CC 4.0 BY-SA版权
文章标签： IO进程 共享内存 信号灯集 消息队列
于 2024-10-24 23:56:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_63791423/article/details/143222803

5.共享内存

5.1 特点

1）共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。

2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程

将其映射到自己的私有地址空间。进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。

3）由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

5.2 步骤

a. 创建key值

b. 创建或打开共享内存

c. 映射共享内存到用户空间

d. 撤销映射

e. 删除共享内存

5.3 函数接口

key_t ftok(const char *pathname, int proj_id);
功能：创建出来的具有唯一映射关系的一个key值，帮助操作系统用来标识一块共享内存
参数：
    Pathname：已经存在的可访问文件的名字
    Proj_id：一个字符（因为只用低8位）
返回值：成功：key值
      失败：-1

int shmget(key_t key, size_t size, int shmflg);
功能：创建或打开共享内存
参数：
    key  键值
    size   共享内存的大小
    shmflg   IPC_CREAT|IPC_EXCL|0777
返回值：成功  shmid
      出错    -1
注意对错误的处理方式：
如果错误是file exist光打开共享内存不用设IPC_CREAT|IPC_EXCL了，加判断，如：if(errno == EEXIST)

void  *shmat(int  shmid,const  void  *shmaddr,int  shmflg); //attaches
功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
参数：
    shmid   共享内存的id号
    shmaddr   一般为NULL，表示由系统自动完成映射
              如果不为NULL，那么有用户指定
    shmflg：SHM_RDONLY就是对该共享内存只进行读操作
                0     可读可写
返回值：成功：完成映射后的地址，
       出错：-1（地址）
用法：if((p = (char *)shmat(shmid，NULL,0)) == (char *)-1)

int shmdt(const void *shmaddr); //detaches
功能：取消映射
参数：要取消的地址
返回值：成功0  
      失败的-1

int  shmctl(int  shmid,int  cmd,struct shmid_ds *buf); //control
功能：(删除共享内存)，对共享内存进行各种操作
参数：
    shmid   共享内存的id号
    cmd     IPC_STAT 获得shmid属性信息，存放在第三参数
            IPC_SET 设置shmid属性信息，要设置的属性放在第三参数
            IPC_RMID:删除共享内存，此时第三个参数为NULL即可
    buf    shmid所指向的共享内存的地址,空间被释放以后地址就赋值为null
返回：成功0 
     失败-1
用法：shmctl(shmid,IPC_RMID,NULL);


#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    char *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                //如果共享内存已存在则，直接打开
            shmid = shmget(key, 128, 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL,0);
    if(p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //操作共享内存
    scanf("%s",p);
    printf("%s\n", p);

    //取消映射
    shmdt(p);

    //删除共享内存
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

进程间通信:

5.4. 命令：

ipcs -m: 查看系统中的共享内存

ipcrm -m shmid：删除共享内存

ps: 可能不能直接删除掉还存在进程使用的共享内存。

这时候可以用ps -ef对进程进行查看，kill掉多余的进程后，再使用ipcs查看。

练习：两个进程实现通信，一个进程循环从终端输入，另一个进程循环打印，当输入quit时结束

这两个标志在两个进程里，是不共享的，所以为了共享标志位可以和buf封装到一个结构体里作为共享内存。

struct msg

{

int flag;

char buf[32];

};

input:

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>

struct msg
{
    int flag;
    char buf[32];
};

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    struct msg *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, sizeof(struct msg), IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                               //如果共享内存已存在则，直接打开
            shmid = shmget(key, sizeof(struct msg), 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (struct msg *)shmat(shmid, NULL, 0);
    if (p == (struct msg *)-1)
    {
        perror("shmat err");
        return -1;
    }

    p->flag = 0;
    while (1)
    {
        if (p->flag == 0)
        {
            scanf("%s", p->buf);
            p->flag = 1;
        }
        if (strcmp(p->buf, "quit") == 0)
            break;
    }

    //取消映射
    shmdt(p);

    //删除共享内存
    //shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

output:

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>

struct msg
{
    int flag;
    char buf[32];
};

int main(int argc, char const *argv[])
{
    int shmid;
    key_t key;
    struct msg *p;
    key = ftok("shm.c", 'a');
    if (key < 0)
    {
        perror("key err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建共享内存
    shmid = shmget(key, sizeof(struct msg), IPC_CREAT | IPC_EXCL | 0777); //如果共享内存不存在则创建，存在则返回-1
    if (shmid <= 0)
    {
        if (errno == EEXIST)                               //如果共享内存已存在则，直接打开
            shmid = shmget(key, sizeof(struct msg), 0777); //直接打开已有的共享内存并且获得共享内存id
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (struct msg *)shmat(shmid, NULL, 0);
    if (p == (struct msg *)-1)
    {
        perror("shmat err");
        return -1;
    }

    p->flag = 0;
    while (1)
    {
        if (strcmp(p->buf, "quit") == 0)
            break;
        if (p->flag == 1)
        {
            printf("%s\n", p->buf);
            p->flag = 0;
        }
    }

    //取消映射
    shmdt(p);

    //删除共享内存
    //shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

6.信号灯集

线程：全局变量，同步通过信号量

初始化: sem_init(&sem,0,0);

申请资源：sem_wait(&sem); P操作，-1

释放资源：sem_post(&sem); V操作，+1

6.1 特点

信号灯(semaphore)，也叫信号量，信号灯集是一个信号灯的集合。它是不同进程间或一个给定进程内部不同线程间同步的机制；

而Posix信号灯指的是单个计数信号灯：无名信号灯、有名信号灯。（咱们学的是无名信号灯）

System V的信号灯是一个或者多个信号灯的一个集合。其中的每一个都是单独的计数信号灯。

通过信号灯集实现共享内存的同步操作

6.2 步骤

  1. 创建key值：ftok
  2. 创建或打开信号灯集: semget
  3. 初始化信号灯: semctl
  4. PV操作: semop
  5. 删除信号灯集: semctl

6.3 命令

ipcs -s: 查看信号灯集

ipcrm -s semid: 删除信号灯集

注意：有时候可能会创建失败，或者semid为0，所以用命令看看，删了重新创建就可以了。

6.4 函数接口

int semget(key_t key, int nsems, int semflg);
功能：创建/打开信号灯
参数：key：ftok产生的key值
    nsems：信号灯集中包含的信号灯数目
    semflg：信号灯集的访问权限，通常为IPC_CREAT|IPC_EXCL|0666
返回值：成功：信号灯集ID
       失败：-1

int semctl ( int semid, int semnum,  int cmd…/*union semun arg*/);
功能：信号灯集合的控制（初始化/删除）
参数：semid：信号灯集ID
    semnum: 要操作的集合中的信号灯编号，信号灯编号从0开始
     cmd： 
        GETVAL：获取信号灯的值，返回值是获得值
        SETVAL：设置信号灯的值，需要用到第四个参数：共用体
        IPC_RMID：从系统中删除信号灯集合
返回值：成功 0
      失败 -1

用法：
1. 初始化信号灯集中信号灯:
需要自定义共用体:
union semun
{
    int val;
};
union semun mysemun;
mysemun.val=10;
semctl(semid, 0, SETVAL, mysemun);

2. 获取信号灯值: 函数 semctl(semid,0,GETVAL); 的返回值

3. 删除信号灯集: semctl(semid,0,IPC_RMID); 这里传任意一个信号灯的编号就可以删除整个信号灯集了


int semop ( int semid, struct sembuf  *opsptr,  size_t  nops);
功能：对信号灯集合中的信号量进行PV操作
参数：semid：信号灯集ID
     opsptr:操作方式
     nops:  要操作的信号灯的个数 1个
返回值：成功 ：0
      失败：-1

struct sembuf {
   short  sem_num; // 要操作的信号灯的编号
   short  sem_op;  //    0 :  等待，直到信号灯的值变成0
                   //   1  :  释放资源，V操作
                   //   -1 :  申请资源，P操作                    
    short  sem_flg; // 0（阻塞）,IPC_NOWAIT, SEM_UNDO
};

用法：
申请资源操作：
struct sembuf mysembuf;
mysembuf.sem_num=0;
mysembuf.sem_op=-1;
mysembuf.sem_flg=0;
semop(semid,&mysembuf,1);

释放资源操作：
mysembuf.sem_num=1;
mysembuf.sem_op=1;
mysembuf.sem_flg=0;
semop(semid,&mysembuf,1);

创建信号灯集:

使用信号灯集:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
union semun
{
    int val;
};

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        union semun sem;
        sem.val = 10;
        semctl(semid, 0, SETVAL, sem); //把0号信号灯初始化值为10

        sem.val = 0;
        semctl(semid, 1, SETVAL, sem); //把1号信号灯初始化值为0
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    //PV操作
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = 0;
    buf.sem_op = -1; //申请资源，P操作，-1
    buf.sem_flg = 0; //阻塞
    semop(semid, &buf, 1); //对0号灯进行P操作申请资源

    buf.sem_num = 1;
    buf.sem_op = 1;  //释放资源，V操作，+1
    buf.sem_flg = 0; //阻塞
    semop(semid, &buf, 1); //对1号灯进行V操作释放资源

    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    // //删除信号灯集
    // semctl(semid, 0, IPC_RMID);   //任意传一个信号灯的编号就可以删除整个信号灯集了
    return 0;
}

函数操作：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 10); //把0号信号灯初始化值为10
        init(semid, 1, 0);  //把1号信号灯初始化值为0
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    //PV操作
    pv(semid, 0, -1); //对0号灯P操作
    pv(semid, 1, 1);  //对1号灯V操作

    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    // //删除信号灯集
    // semctl(semid, 0, IPC_RMID);   //任意传一个信号灯的编号就可以删除整个信号灯集了
    return 0;
}

把信号灯集加到共享内存实现同步：输入输出quit结束

input:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
#include <sys/shm.h>
#include <string.h>

union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;
    int shmid;
    char *p;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
            shmid = shmget(key, 128, 0777);
        else
        {
            perror("shmget er");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 0); //把0号信号灯初始化值为0
        init(semid, 1, 1); //把1号信号灯初始化值为1
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("sem0: %d\n", semctl(semid, 0, GETVAL));
    printf("sem1: %d\n", semctl(semid, 1, GETVAL));

    while (1)
    {
        pv(semid, 1, -1);
        scanf("%s", p);
        pv(semid, 0, 1);
        if (strcmp(p, "quit") == 0)
            break;
    }

    shmdt(p);                      //取消映射
    // shmctl(shmid, IPC_RMID, NULL); //删除共享内存
    // semctl(semid, 0, IPC_RMID);    //删除信号灯集
    return 0;
}

output:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
#include <sys/shm.h>
#include <string.h>

union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;
    int shmid;
    char *p;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
            shmid = shmget(key, 128, 0777);
        else
        {
            perror("shmget er");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 0); //把0号信号灯初始化值为0
        init(semid, 1, 1); //把1号信号灯初始化值为1
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("sem0: %d\n", semctl(semid, 0, GETVAL));
    printf("sem1: %d\n", semctl(semid, 1, GETVAL));

    while (1)
    {
        pv(semid, 0, -1);
        if (strcmp(p, "quit") == 0)
            break;
        printf("shm: %s\n", p);
        pv(semid, 1, 1);
    }

    shmdt(p);                      //取消映射
    shmctl(shmid, IPC_RMID, NULL); //删除共享内存
    semctl(semid, 0, IPC_RMID);    //删除信号灯集
    return 0;
}

7.消息队列 message queue

传统：无名管道、有名管道、信号

system V: 共享内存、信号灯集、消息队列

队列原则

按消息的类型添加或读取消息

7.1. 特点：

消息队列是IPC对象(活动在内核级别的一种进程间通信的工具)的一种

一个消息队列由一个标识符 (即队列ID)来标识

消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等

消息队列可以按照类型(自己设一个值作为类型)来发送/接收消息

7.2 步骤

  1. 创建key值: ftok
  2. 创建或打开消息队列: msgget
  3. 添加消息：按照消息的类型把消息添加到已经打开的消息队列末尾 msgsnd
  4. 读取消息：可以按照消息类型把消息从消息队列中取走 msgrcv
  5. 删除消息队列: msgctl

7.3 操作命令

ipcs -q: 查看消息队列

ipcrm -q msgid: 删除消息队列

7.4 函数接口

int msgget(key_t key, int flag);
功能：创建或打开一个消息队列
参数：  key值
       flag：创建消息队列的权限IPC_CREAT|IPC_EXCL|0666
返回值：成功：msgid
       失败：-1

int msgsnd(int msqid, const void *msgp, size_t size, int flag); 
功能：添加消息
参数：msqid：消息队列的ID
      msgp：指向消息的指针。常用消息结构msgbuf如下：
          struct msgbuf{
            long mtype;          //消息类型
            char mtext[N]}；     //消息正文
   size：发送的消息正文的字节数
   flag：IPC_NOWAIT消息没有发送完成函数也会立即返回    
         0：直到发送完成函数才返回
返回值：成功：0
      失败：-1
用法： msgsnd(msgid, &msg, sizeof(msg)-sizeof(long),0);

int msgrcv(int msgid,  void* msgp,  size_t  size,  long msgtype,  int  flag);
功能：读取消息
参数：msgid：消息队列的ID
     msgp：存放读取消息的空间
     size：接受的消息正文的字节数(sizeof(msgp)-sizeof(long))
    msgtype：
            0：接收消息队列中第一个消息。
            大于0：接收消息队列中第一个类型为msgtyp的消息.
            小于0：接收消息队列中类型值不小于msgtyp的绝对值且类型值又最小的消息。
     flag：
           0：若无消息函数会一直阻塞
           IPC_NOWAIT：若没有消息，进程会立即返回ENOMSG
返回值：成功：接收到的消息的长度
      失败：-1

int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );
功能：对消息队列的操作，删除消息队列
参数：msqid：消息队列的队列ID
     cmd：
        IPC_STAT：读取消息队列的属性，并将其保存在buf指向的缓冲区中。
        IPC_SET：设置消息队列的属性。这个值取自buf参数。
        IPC_RMID：从系统中删除消息队列。
     buf：消息队列缓冲区
返回值：成功：0
      失败：-1
用法：msgctl（msgid, IPC_RMID, NULL）；

打开或创建消息队列：

操作消息队列：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>

struct msgbuf
{
    long type; //必须有，在第一个，表示消息的类型，值>0!
    int num;   //消息正文，自己定义
    char ch;
};

int main(int argc, char const *argv[])
{
    key_t key;
    int msgid;

    if ((key = ftok("msg.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建消息队列
    msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0777);
    if (msgid <= 0)
    {
        if (errno == EEXIST)
            msgid = msgget(key, 0777); //如果已经存在消息队列那直接打开该消息队列
        else
        {
            perror("msgget err");
            return -1;
        }
    }
    printf("msgid: %d\n", msgid);

    //添加消息
    struct msgbuf msg;
    msg.type = 10;
    msg.num = 1000;
    msg.ch = 'a';
    msgsnd(msgid, &msg, sizeof(msg) - sizeof(long), 0); //0:发完消息再返回，而不是立即返回函数

    msg.type = 20;
    msg.num = 2000;
    msg.ch = 'b';
    msgsnd(msgid, &msg, sizeof(msg) - sizeof(long), 0);

    //读取消息
    struct msgbuf m;
    msgrcv(msgid, &m, sizeof(m) - sizeof(long), 20, 0); //0:阻塞，读完消息再返回

    printf("%d %c\n", m.num, m.ch);

    //删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

进程间通信：

总结： IO进程

IO部分:

  1. 标准IO： 概念、特点、函数(fopen/freopen、fclose、fgetc/fputc、fgets/fputs、fread/fwrite、rewind/fseek/ftell)

练习：cat、wc -l、head、计算时间、cp

  1. 文件IO：概念、特点、函数(open、close、read、write、lseek)

练习：cp

  1. 文件属性获取：stat
  2. 目录操作: opendir、closedir、readdir、chdir

进程部分：

    1. 进程基础: 进程和程序的区别、特点、三个段、分类、状态、函数(fork、wait/waitpid、exit/_exit、getpid/getppid、exec函数组)、守护进程(特点、步骤)

练习: 父子进程实现cp

    2. 线程基础：和进程的区别、函数(pthread_create、pthread_join/pthread_detach、pthread_exit)、同步(信号量、函数sem_init/sem_wait/sem_post)、互斥(互斥锁、函数pthread_mutex_init/pthread_mutex_lock/pthread_mutex_unlock/phtread_mutex_destroy)、条件变量(和互斥锁搭配实现同步、函数pthread_cond_init/pthread_cond_wait/pthread_cond_signal/pthread_cond_destroy)

    3. 进程间通信：

无名管道：特点、pipe、步骤

有名管道：特点、mkfifo、步骤

信号：特点（异步）、信号处理方式、函数

共享内存：特点、步骤、函数

信号灯集：特点、步骤、函数

消息队列：特点、步骤、函数

面试题

  1. 标准IO和文件IO的区别是什么？
  2. 什么是库，静态库和动态库的区别？
  3. 什么是孤儿进程？什么是僵尸进程？
  4. 什么是守护进程？创建步骤？
  5. 进程和线程的区别？
  6. 线程的同步和互斥，怎么实现？什么是异步？什么是阻塞? 什么是非阻塞?
  7. 进程间通讯方式有哪些，分别描述一下？效率最高是哪种?
  8. 无名管道和有名管道的区别？
文件IO_day1.pdf
02-21
文件IO_day1.pdf 本资源摘要信息涵盖了文件IO的基本概念、Linux文件IO、赫夫曼树赫夫曼编码、静态库和动态库、文件I/O分类、Linux输出机制、文件操作函数等知识点。 1.赫夫曼树赫夫曼编码 赫夫曼树赫夫曼编码是一...
IO进程线程Day5 文件夹拷贝
04-04
文件夹拷贝
C# .Net 多进程同步 通信 共享内存 内存映射文件 Memory Mapped
weixin_30595035的博客
07-16 215
节点通信存在两种模型：共享内存（Shared memory）和消息传递（Messages passing）。 内存映射文件对于托管世界的开发人员来说似乎很陌生，但它确实已经是很远古的技术了，而且在操作系统中地位相当。实际上，任何想要共享数据的通信模型都会在幕后使用它。 内存映射文件究竟是个什么？内存映射文件允许你保留一块地址空间，然后将该物理存储映射到这块内存空...
进程间通信方式（共享内存、信号灯集、消息队列）
weixin_62345907的博客
09-04 1003
共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。信号灯(semaphore)，也叫信号量，信号灯集是一个信号灯的集合。它是不同进程间或一个给定进程内部不同线程间同步的机制。消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等，消息队列可以按照类型(自己设一个值作为类型)来发送/接收消息。
IO进程_day1
weixin_63791423的博客
10-20 953
标准IO/行缓存/全缓存不缓存/open()/close()/fgetc()/fputc ()fgets()/fputs()/二进制读写文件fread()/fwrite/文件定位操作rewind()、seek()、ftell()
IO进程_day4
weixin_63791423的博客
10-22 1172
进程 process/进程段/进程分类/进程状态/进程状态切换图/阻塞和非阻塞/优先级调度/进程函数接口/创建进程 fork()/回收资源/结束进程/获取进程号/exec函数族/守护进程/守护进程的特点
IO进程 day01
lymdcsdn的博客
02-19 1376
课程介绍，IO，标准IO和文件IO，缓存机制，标准IO特点，流，缓存区分类，计算缓存区大小，fflush，fopen/fclose,fgetc/fputc,fgets/fputs,perror,fprintf
IO进程 day04
lymdcsdn的博客
02-21 1196
进程和程序的区别，进程的特点，进程的分段，进程的类型，进程的运行状态，进程的状态转换图，进程函数：fork，wait,eixt,getpid；exec函数族
IO进程 day06
lymdcsdn的博客
02-25 823
线程间通信：死锁；进程间通信，无名管道，有名管道
IO进程线程Day7
2301_81402136的博客
05-13 286
【代码】IO进程线程Day7。
IO进程线程day7
weixin_69331128的博客
03-13 488
【代码】IO进程线程day7。
day7_IO进程线程
This is why we play
08-22 225
day7_IO进程线程思维导图 思维导图
IO进程线程Day5 文件夹拷贝 从文件中读取数据到内存，从内存写入到文件 父子进程发送消息
04-04
今天我们将深入探讨“IO进程线程Day5”中的核心知识点，包括文件夹拷贝、从文件读取数据到内存以及内存到文件的写入，以及父子进程间的消息传递。 首先，让我们关注文件夹拷贝这一过程。文件夹拷贝不仅仅是简单的...
DAY3 IO进程线程 文本IO函数
09-08
DAY3 IO进程线程 文本IO函数
MPU9250九轴传感器数据融合：扩展卡尔曼滤波（EKF）算法解析与应用——以四元数、陀螺仪和加速度计为核心 · 四元数
08-13
MPU9250 九轴传感器的工作原理及其应用背景，重点讲解了如何利用扩展卡尔曼滤波 (EKF) 进行数据融合。文中解释了选择四元数作为状态量、三轴陀螺仪的漂移作为控制量以及三轴加速度计和磁偏角作为观测量的原因。通过这种方式，在短时间尺度上优先信任陀螺仪提供的高精度角速度数据，而在长时间尺度上则依赖于加速度计提供的稳定姿态信息。此外，还提供了 Python 实现的简单 EKF 数据融合算法代码示例。 适合人群：对传感器数据融合感兴趣的电子工程技术人员、自动化控制领域的研究人员、从事机器人导航系统开发的技术人员。 使用场景及目标：适用于需要精确测量和稳定控制的场合，如无人机飞行控制系统、自动驾驶汽车的姿态感知模块、智能穿戴设备的动作捕捉单元等。目的是提高运动信息的准确性与稳定性。 其他说明：本文不仅理论阐述详尽，而且附有实际代码示例，便于读者理解和实践。对于希望深入了解传感器数据融合技术并掌握其实现细节的专业人士而言，是一份非常有价值的参考资料。
S7-200与MCGS PLC控制抽水泵系统：梯形图程序、接线图及组态画面解析 梯形图
08-13
No.201 S7-200与MCGS PLC在控制抽水泵系统中的应用。首先，文章讲解了梯形图程序作为控制逻辑的关键组成部分，展示了如何通过梯形图实现自动化控制，如当水位低于设定值时启动抽水泵电机。其次，文章阐述了IO分配与接线图原理图的重要性，通过合理的输入输出分配，确保系统的高效稳定运行。最后，文章介绍了MCGS PLC的组态画面，使操作人员能实时监控和管理系统，提供便捷的操作界面和故障排查工具。 适合人群：从事工业自动化领域的工程师和技术人员，特别是对PLC控制系统有一定了解的人群。 使用场景及目标：适用于需要理解和掌握S7-200与MCGS PLC在抽水泵系统中的具体应用场合，帮助工程师和技术人员更好地设计、安装和维护此类系统。 其他说明：文章不仅提供了理论知识，还附有具体的实例和图表，便于读者理解和实践。
威纶通触摸屏配方管理模板（含图库与宏程序详解）
08-13
内容概要：本文深入介绍了威纶通触摸屏配方管理模板的应用，涵盖从模板概览、文件构成到宏程序详解等多个方面。首先，模板包含完整的图库、原图和PS原文件，用户可以通过直接拖拽的方式快速设计触摸屏界面，或者对原文件进行个性化修改。其次，文中详细解释了宏程序的工作原理，以一个简单的照明控制系统为例，展示了如何利用宏程序实现灯光的开关控制。最后，文章强调了这套模板在实际应用中的灵活性和高效性，无论是简单控制还是复杂工艺流程，都能提供极大便利。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是需要使用威纶通触摸屏进行项目开发的人员。 使用场景及目标：适用于各类工业控制场景，旨在提高工作效率，简化触摸屏界面设计和配置过程，帮助用户更好地理解和应用宏程序。 其他说明：本文不仅提供了理论指导，还通过具体实例进行了操作演示，确保读者能够在实践中掌握相关技能。
DC-Buck芯片TPS56637 4.5V-28V输入,6A
最新发布
08-13
同步降压，三阶环路调节
### 【工业自动化】西门子梯形图程序转换手册：指令与内存映射解析
08-13
内容概要：本文档是西门子梯形图程序转换器的操作手册附录，版本为 Rev 1.10。主要内容包括三大部分：指令转换列表、指令转换解决方案以及I/O内存转换表。指令转换列表详细列出了从S7-200到不同型号PLC（如CP1E、CP1L、CP1H）之间的指令对应关系，涵盖了逻辑操作、比较、定时器、计数器、数据移动、算术运算、转换指令等。对于某些复杂指令，提供了详细的转换解决方案。I/O内存转换表则详细说明了S7-200与各型号PLC之间输入输出寄存器、变量存储器、位存储器、定时器、计数器等内存区域的映射关系。此外，还包括特殊内存位的转换对照。 适合人群：具有PLC编程基础的技术人员，特别是从事西门子S7-200系列PLC向其他品牌或型号PLC迁移工作的工程师。 使用场景及目标：①帮助工程师将现有S7-200程序迁移到其他型号PLC上；②确保转换后的程序逻辑正确性和功能完整性；③提供详细的转换规则和步骤，减少迁移过程中可能出现的问题。 其他说明：文档提供了详尽的指令和内存映射表，适用于多种应用场景。工程师可以根据具体需求选择合适的转换方案，并参考提供的详细说明进行实际操作。同时，对于一些复杂指令，文档给出了具体的转换方法和注意事项，有助于提高迁移的成功率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值