进程间通信2-消息队列、共享内存、线程、互斥锁、信号量

最新推荐文章于 2023-09-07 11:55:31 发布
最新推荐文章于 2023-09-07 11:55:31 发布
阅读量458 收藏 2
点赞数 1
分类专栏： c语言基础 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27751235/article/details/132154825
版权

主要进程间通信的通信机制

Linux操作系统支持的主要进程间通信的通信机制
在这里插入图片描述

IPC对象，会在当前系统中可见，只要不删除或者不关闭系统，就会一直存在

查看已经创建的IPC对象

查看已经创建的IPC对象

ipcs 查看当前系统中所有创建的IPC对象
ipcs -q 查看创建的消息队列
ipcs -m 查看创建的共享内存
ipcs -s 查看信号量

ipcrm 删除IPC对象

例如：ipcrm -q msqid 删除标号为msqid的消息队列

消息队列

消息队列：是消息的链表，存放在内存中，由内核维护
特点：

  • 1、消息队列中的消息是有类型的
  • 2、消息队列中的消息是有格式的
  • 3、消息队列可以实现消息的随机查询。消息不一定要以先进先出的次序读取，编程时可以按消息的类型读取
  • 4、消息队列允许一个或多个进程向它写入或者读取消息
  • 5、与无名管道、命名管道一样，从消息队列中读出消息，消息队列中对应的数据都会被删除
  • 6、每个消息队列都有消息队列标识符，消息队列的标识符在整个系统中是唯一的
  • 7、只有内核重启或人工删除消息队列时，该消息队列才会被删除。若不人工删除消息队列，消息队列会一直存在于系统中

在这里插入图片描述

  • System V提供的IPC通信机制需要一个key值，通过key值就可在系统内获得一个唯一的消息队列标识符。
  • key值可以是人为指定的，也可以通过ftok函数获得
    在这里插入图片描述

ftok函数

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

  • 功能：获得项目相关的唯一的IPC键值
  • 参数：
    • pathname：路径名
    • proj_id：项目id，非0整数（只有低8位有效）
  • 返回值：成功返回 key值，失败返回 -1

如果使用ftok函数获取键值，得到的键值是有ftok的第一个参数对应文件的信息和第二个参数一起决定的

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    printf("key = %#x\n", mykey);    // key = 0x64010006


    return 0;
}

创建消息队列-msgget

创建消息队列-msgget

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);

  • 功能：创建一个新的或打开一个已经存在的消息队列。不同的进程调用此函数，只要用相同的key值就能得到同一个消息队列的标识符

  • 参数：

    • key：IPC键值，唯一的键值确定唯一的消息队列

    方法1：任意指定一个数
    方法2：使用ftok函数获取键值

    • msgflg：标识函数的行为及消息队列的权限

    msgflg的取值：
    IPC_CREAT：创建消息队列
    IPC_EXCL：检测消息队列是否存在
    位或权限位：消息队列位或权限位后可以设置消息队列的访问权限，格式和open函数的mode_t一样，但可执行权限未使用

  • 返回值：

    • 成功：消息队列的标识符
    • 失败：返回 -1

msgflg：消息队列的访问权限
一般设置为：
IPC_CREAT | IPC_EXCL | 0777 或者 IPC_CREAT | 0777

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

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }
    printf("mykey = %#x\n", mykey);

    // 通过msgget函数创建一个消息队列
    int msqid1;
    if((msqid1 = msgget(mykey, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to msgget");
        exit(1);
    }
    printf("msqid1 = %d\n", msqid1);

    system("ipcs -q");

    return 0;
}

在这里插入图片描述

ipcs -q 查看创建的消息队列
ipcrm -q msqid 删除标号为msqid的消息队列

消息队列-发送消息msgsnd

#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

  • 功能：将新消息添加到消息队列

  • 参数：

    • msqid：消息队列的标识符
    • msgp：待发送消息结构体的地址
    • msgsz：消息正文的字节数，不包括消息的编号长度
    • msgflg：函数的控制属性

    0：msgsnd调用阻塞直到条件满足为止
    IPC_NOWAIT：若消息没有立即发送则调用该函数的进程会立即返回

  • 返回值：

    • 成功：0
    • 失败：返回 -1

消息队列的消息格式

typedef struct_msg
{
long mtype; /* 消息类型 /
char mtext[100]; / 消息正文 /
… / 消息的正文可以有多个成员 */
}MSG;

消息类型必须是长整型的，而且必须是结构体类型的第一个成员，类型下面是消息正文，正文可以有多个成员（正文成员可以是任意数据类型的）

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

#define N 128

typedef struct{
    long msg_type;  // 消息类型，必须在结构体的第一个位置并且类型必须是long
    char msg_text[N];  // 消息正文
}MSG;

#define MSGTEXT_SIZE (sizeof(MSG) - sizeof(long))

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }
    printf("mykey = %#x\n", mykey);

    // 通过msgget函数创建一个消息队列
    int msqid1;
    if((msqid1 = msgget(mykey, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to msgget");
        exit(1);
    }
    printf("msqid1 = %d\n", msqid1);

    system("ipcs -q");

    // 使用msgsnd函数向消息队列中发送数据（写操作）
    MSG msg1={1,"hello world"};
    MSG msg2={4,"beijing"};
    MSG msg3={2,"hello kitty"};
    MSG msg4={3,"welcome to xxxx"};

    if(msgsnd(msqid1, &msg1, MSGTEXT_SIZE, 0) == -1)
    {
        perror("fail to msgsnd");
        exit(1);
    }
    if(msgsnd(msqid1, &msg2, MSGTEXT_SIZE, 0) == -1)
    {
        perror("fail to msgsnd");
        exit(1);
    }
    if(msgsnd(msqid1, &msg3, MSGTEXT_SIZE, 0) == -1)
    {
        perror("fail to msgsnd");
        exit(1);
    }
    if(msgsnd(msqid1, &msg3, MSGTEXT_SIZE, 0) == -1)
    {
        perror("fail to msgsnd");
        exit(1);
    }

    system("ipcs -q");

    return 0;
}

在这里插入图片描述

消息队列-接收消息msgrcv

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

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);

  • 功能：

    • 从标识符为msqid的消息队列中接收一个消息。一旦接收消息成功，则消息在消息队列中被删除

  • 参数：

    • msqid：消息队列的标识符，代表要从哪个消息队列中获取消息
    • msgp：存放消息结构体的地址
    • msgsz：消息正文的字节数
    • msgtyp：消息的类型、可以有以下几种类型

    msgtyp = 0：返回队列中第一个消息
    msgtyp > 0：返回队列中消息类型为msgtyp的消息
    msgtyp < 0：返回队列中消息类型值小于或等于msgtyp绝对值的消息，如果这种消息有若干个，则取类型值最小的消息

  • msgflg：函数的控制属性

0：msgrcv调用阻塞直到接收消息成功为止
MSG_NOERROR：若返回的消息字节数比nbytes字节数多，则消息就会截短到nbytes字节，且不通知消息发送进程
IPC_NOWAIT：调用进程会立即返回。若没有收到消息则立即返回 -1

注意：
1、若消息队列中有多种类型的消息，msgrcv获取消息的时候按消息类型获取，不是先进先出的。
2、在获取某类型消息的时候，若队列中有多条此类型的消息，则获取最先添加的消息，即先进先出原则。

  • 返回值：
    • 成功：返回读取消息的长度
    • 失败：返回 -1
#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define N 128

typedef struct{
    long msg_type;  // 消息类型，必须在结构体的第一个位置并且类型必须是long
    char msg_text[N];  // 消息正文
}MSG;

#define MSGTEXT_SIZE (sizeof(MSG) - sizeof(long))

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过msgget函数创建一个消息队列
    int msqid1;
    if((msqid1 = msgget(mykey, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to msgget");
        exit(1);
    }
    printf("msqid1 = %d\n", msqid1);

    system("ipcs -q");

    // 通过msgrcv函数接收消息队列中的信息（读操作）
    MSG msg;
    // if(msgrcv(msqid1, &msg, MSGTEXT_SIZE, 0, 0) == -1)

    // 如果没有第四个参数指定的消息时，msgrcv函数会阻塞等待
    if(msgrcv(msqid1, &msg, MSGTEXT_SIZE, 2, 0) == -1)
    {
        perror("fail to msgrcv");
        exit(1);
    }

    printf("recv_msg = %s\n", msg.msg_text);

    system("ipcs -q");

    return 0;
}

消息队列的控制

消息队列的控制

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

  • 功能：对消息队列进行各种控制，如修改消息队列的属性，或删除消息队列
  • 参数
    • msqid：消息队列的标识符
    • cmd：函数功能的控制
    • buf：msqid_ds数据类型的地址，用来存放或更改消息队列的属性

cmd：函数功能的控制

1、IPC_RMID：删除由msqid指示的消息队列，将它从系统中删除并破坏相关数据结构
2、IPC_STAT：将msqid相关的数据结构中各个元素的当前值存入到由buf指向的结构中
3、IPC_SET：将msqid相关的数据结构中的元素设置为由buf指向的结构中的对应值

  • 返回值：成功返回0，失败返回 -1
#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define N 128

typedef struct{
    long msg_type;  // 消息类型，必须在结构体的第一个位置并且类型必须是long
    char msg_text[N];  // 消息正文
}MSG;

#define MSGTEXT_SIZE (sizeof(MSG) - sizeof(long))

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过msgget函数创建一个消息队列
    int msqid1;
    if((msqid1 = msgget(mykey, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to msgget");
        exit(1);
    }
    printf("msqid1 = %d\n", msqid1);

    system("ipcs -q");


    // 通过msgctl函数删除消息队列
    if(msgctl(msqid1, IPC_RMID, NULL)  == -1)
    {
        perror("fail to msgctl");
        exit(1);
    }

    system("ipcs -q");

    return 0;
}

共享内存

共享内存：允许两个或多个进程共享给定的存储区域
共享内存的特点：
1、共享内存是进程间共享数据的一种最快的方法

一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容

2、使用共享内存要注意的是多个进程之间对一个给定存储区访问的互斥

若一个进程正在向共享内存区写数据，则在它做完这一步操作前，别的进程不应当去读、写这些数据

在这里插入图片描述

获得一个共享存储标识符-shmget

获得一个共享存储标识符-shmget

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

使用shell命令操作共享内存

查看共享内存
ipcs -m
删除共享内存
ipcrm -m shmid

共享内存映射（attach）
在这里插入图片描述
在这里插入图片描述

解除共享内存映射（detach）
在这里插入图片描述

使用共享内存实现读写操作

使用共享内存实现读写操作

write案例，写char *类型数据

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


int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过shmget函数创建或打开一个共享内存，返回一个共享内存的标识符
    int shmid;
    if((shmid = shmget(mykey, 500, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to shmget");
        exit(1);
    }

    printf("shmid = %d\n", shmid);
    system("ipcs -m");


    // 使用shmat函数映射共享内存的地址
    char *text;
    if((text = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("fail to shmat");
        exit(1);
    }

    // 通过shmat的返回值对共享内存操作
    strcpy(text, "hello world");

    // 操作完毕后要解除共享内存的映射
    if(shmdt(text) == -1)
    {
        perror("fail to shmdt");
        exit(1);
    }


    return 0;
}

read案例，读char *类型数据

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


int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过shmget函数创建或打开一个共享内存，返回一个共享内存的标识符
    int shmid;
    if((shmid = shmget(mykey, 500, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to shmget");
        exit(1);
    }

    printf("shmid = %d\n", shmid);
    system("ipcs -m");


    // 使用shmat函数映射共享内存的地址
    char *text;
    if((text = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("fail to shmat");
        exit(1);
    }

    // 通过shmat的返回值, 获取共享内存中的数据
    printf("text = %s\n", text);

    // 操作完毕后要解除共享内存的映射
    if(shmdt(text) == -1)
    {
        perror("fail to shmdt");
        exit(1);
    }
    system("ipcs -m");

    return 0;
}

案例2
写和读 结构体类型数据

写

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

typedef struct{
    int a;
    char b;
}MSG;

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过shmget函数创建或打开一个共享内存，返回一个共享内存的标识符
    int shmid;
    if((shmid = shmget(mykey, 500, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to shmget");
        exit(1);
    }

    printf("shmid = %d\n", shmid);
    system("ipcs -m");


    // 使用shmat函数映射共享内存的地址
    // char *text;

    MSG *text;
    if((text = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("fail to shmat");
        exit(1);
    }

    // 通过shmat的返回值对共享内存操作
    // strcpy(text, "hello world");

    text->a = 100;
    text->b = 'w';

    // 操作完毕后要解除共享内存的映射
    if(shmdt(text) == -1)
    {
        perror("fail to shmdt");
        exit(1);
    }
    system("ipcs -m");


    return 0;
}

读


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

typedef struct{
    int a;
    char b;
}MSG;

int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过shmget函数创建或打开一个共享内存，返回一个共享内存的标识符
    int shmid;
    if((shmid = shmget(mykey, 500, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to shmget");
        exit(1);
    }

    printf("shmid = %d\n", shmid);
    system("ipcs -m");


    // 使用shmat函数映射共享内存的地址
    // char *text;

    MSG *text;
    if((text = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("fail to shmat");
        exit(1);
    }

    // 通过shmat的返回值, 获取共享内存中的数据
    // printf("text = %s\n", text);

    printf("a = %d, b = %c\n", text->a, text->b);

    // 操作完毕后要解除共享内存的映射
    if(shmdt(text) == -1)
    {
        perror("fail to shmdt");
        exit(1);
    }
    system("ipcs -m");

    return 0;
}

共享内存控制-shmctl

共享内存控制-shmctl
在这里插入图片描述

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


int main()
{
    // 使用ftok函数获取键值
    key_t mykey;
    if((mykey = ftok(".", 100)) == -1)
    {
        perror("fail to ftok");
        exit(1);
    }

    // 通过shmget函数创建或打开一个共享内存，返回一个共享内存的标识符
    int shmid;
    if((shmid = shmget(mykey, 500, IPC_CREAT | 0666)) == -1)
    {
        perror("fail to shmget");
        exit(1);
    }

    printf("shmid = %d\n", shmid);
    system("ipcs -m");

    // 通过shmctl函数删除共享内存
    if(shmctl(shmid, IPC_RMID, NULL) == -1)
    {
        perror("fail to shmctl");
        exit(1);
    }

    system("ipcs -m");

    return 0;
}

线程

线程概念

1、每个进程都拥有自己的数据段、代码段和堆栈段，这就造成进程在进程创建、切换、撤销操作时，需要较大的系统开销。
2、为了减少系统开销，从进程中演化出了线程
3、线程存在于进程中，共享进程的资源
4、线程是进程中的独立控制流，由环境(包括寄存器组和程序计数器)和一系列的执行指令组成。
5、每个进程都有一个地址空间和一个控制线程

多线程的用途

  • 多任务程序的设计
    • 一个程序可能要处理不同应用，要处理多种任务，如果开发不同的进程来处理，系统开销很大，数据共享，程序结构都不方便，这时可使用多线程编程方法
  • 并发程序设计
    • 一个任务可能分成不同的步骤去完成，这些不同的步骤之间可能是松散耦合，可能通过线程的互斥，同步并发完成。这样可以为不同任务步骤建立线程
  • 网络程序设计
    • 为提供网络的利用效率，我们可能使用多线程，对每个连接用一个线程去处理
  • 数据共享
    • 同一个进程中的不同线程共享进程的数据空间，方便不同线程间的数据共享

在多CPU系统中，实现真正的并行。

线程的创建

线程的创建

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

  • 功能：
    • 创建一个线程
  • 参数
    • thread：线程标识符地址
    • attr：线程属性结构体地址
    • start_routine：线程函数的入口地址
    • arg：传给线程函数的参数
  • 返回值
    • 成功：返回0
    • 失败：返回非0

1、与fork不同的是pthread_create创建的线程不与父线程在同一点开始运行，而是从指定的函数开始运行，该函数运行完后，该线程也就退出了
2、线程依赖进程存在，如果创建线程的进程结束了，线程也就结束了
3、线程函数的程序在pthread库中，故链接时要加上参数-lpthread

注意：由于线程库原本不是系统本身的，所以在链接时需要手动链接库文件 gcc *.c -lpthread
出错的
在这里插入图片描述
正确的

在这里插入图片描述

1、通过pthread_create函数创建子线程

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

#include <pthread.h>

// 由于线程库原本不是系统本身的，所以在链接时需要手动链接库文件 gcc *.c  -lpthread

void *thread_fun(void *arg)
{
    printf("子线程正在运行\n");
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread, NULL, thread_fun, NULL)  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 由于进程结束后，进程中所有的线程都会强制退出，所以现阶段使用while不要让进程退出
    while (1);

    return 0;
}

2、一个进程中的多个线程执行顺序是不确定的，没有先后顺序可言

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

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


// 一个进程中的多个线程执行顺序是不确定的，没有先后顺序可言
// 多线程执行时跟进程一样，是来回切换运行的，跟进程的调度机制一样

void *thread_fun(void *arg)
{
    printf("子线程1正在运行\n");
    sleep(1);
    printf("**************************\n");
}
void *thread_fun2(void *arg)
{
    printf("子线程2正在运行\n");
    sleep(1);
    printf("------------------------\n");
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1,thread2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL)  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }
    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread2, NULL, thread_fun2, NULL)  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    while (1);

    return 0;
}

在这里插入图片描述

3、线程、传参

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

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

int num  =100;

void *thread_fun(void *arg)
{
    printf("子线程1正在运行 num = %d\n",num);
    num++;

    int n = *(int *)arg;
    printf("1 n = %d\n", n);

    *(int *)arg = 111;

}
void *thread_fun2(void *arg)
{
    printf("子线程2正在运行 num = %d\n",num);
    sleep(1);

    int n = *(int *)arg;
    printf("2 n = %d\n", n);
}

int main()
{
    int a = 666;
    printf("主控线程正在执行\n");

    pthread_t thread1,thread2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, (void *)&a )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }
    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread2, NULL, thread_fun2, (void *)&a)  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    while (1);

    return 0;
}

在这里插入图片描述

线程等待

线程等待

在这里插入图片描述

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

void *thread_fun(void *arg)
{
    static int num = 666;

    printf("子线程1正在运行\n");
    sleep(3);
    printf("子线程要退出了\n");

    // 子线程如果要返回退出状态，可以通过返回值或者通过pthread_exit函数
    return (void *)&num;
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;


    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }


    int *num;

    // 通过调用pthread_join函数阻塞等待子线程退出
    // if(pthread_join(thread1, NULL) != 0)
    if(pthread_join(thread1, (void **)&num ) != 0)
    {
        perror("fail to pthread_join");
        exit(1);
    }
    printf("ret_val = %d\n", *num);

    printf("进程要退出了\n");

    return 0;
}

在这里插入图片描述

线程分离

线程分离

线程的结合态和分离态

Linux线程执行和windows不同，pthread有两种状态：
1、可结合的（joinable）或者是分离的（detached），线程默认创建为可结合态。
2、如果线程是joinable状态，当线程函数自己返回退出时或pthread_exit时都不会释放线程所占用堆栈和线程描述符（总计8K多）。只有当你调用了pthread_join之后这些资源才会被释放
3、若是detached状态的线程，这些资源在线程函数退出时或pthread_exit时自动会被释放，使用pthread_detach函数将线程设置为分离态。

创建一个线程后应回收其资源，但使用pthread_join函数会使调用者阻塞，故Linux提供了线程分离函数：pthread_detach。

pthread_detach
在这里插入图片描述

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

void *thread_fun(void *arg)
{
    printf("子线程1正在运行\n");
    sleep(3);
    printf("子线程要退出了\n");
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;


    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 通过pthread_detach函数将子线程设置为分离态，既不用阻塞，也可以自动回收子线程退出的资源
    if(pthread_detach(thread1) != 0)
    {
        perror("fail to pthread_detach");
        exit(1);
    }

    // 通过调用pthread_join函数阻塞等待子线程退出
    // 如果原本子线程是结合态，需要通过pthread_join函数回收子线程退出的资源
    // 但是这个函数是一个阻塞函数，如果子线程不退出，就会导致当前进程（主控线程）无法继续执行，大大的限制了代码的运行效率

    // 如果子线程已经设置为分离态，就不需要再使用pthread_join了
#if 0
    if(pthread_join(thread1, NULL) != 0)
    {
        perror("fail to pthread_join");
        exit(1);
    }
#endif

    while (1)
    {
        printf("hello world\n");
        sleep(1);
    }

    return 0;
}

线程退出


线程退出

在进程中我们可以调用exit函数或_exit函数来结束进程，在一个线程中我们可以通过以下三种在不终止整个进程的情况下停止它的控制流
1、线程从执行函数中返回
2、线程调用pthread_exit退出进程
3、线程可以被同一进程中的其它线程取消

在这里插入图片描述

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

void *thread_fun(void *arg)
{
    printf("子线程1正在运行\n");

    static char buf[] = "This thread has quited";

    int i;
    for(i = 0; i<10; i++)
    {
        if(i == 5)
        {
            // 通过pthread_exit函数退出当前线程
            // pthread_exit(NULL);

            pthread_exit(buf);
        }
        printf("*********\n");
        sleep(1);
    }
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // pthread_join(thread1, NULL);

    char *str;
    pthread_join(thread1, (void **)&str);
    printf("str = %s\n",str);

    printf("进程要退出了\n");

    return 0;
}

在这里插入图片描述

线程的取消pthread_cancel


线程的取消

取消线程是指取消一个正在执行线程的操作

在这里插入图片描述

在这里插入图片描述

案例1

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

void *thread_fun(void *arg)
{
    while (1)
    {
        printf("子线程1正在运行\n");
        sleep(1);
    }
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 通过调用pthread_cancel函数取消另一个线程
    sleep(3);
    pthread_cancel(thread1);

    pthread_join(thread1, NULL);

    printf("进程要退出了\n");

    return 0;
}

在这里插入图片描述

#include <pthread.h>

1、int pthread_setcancelstate(int state, int *oldstate);
2、int pthread_setcanceltype(int type, int *oldtype);

3、void pthread_testcancel(void);

pthread_setcancelstate() ==> 线程的取消状态

在Linux系统下，线程默认可以被取消。编程时可以通过pthread_setcancelstate函数设置线程是否可以被取消。

在这里插入图片描述

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

void *thread_fun(void *arg)
{
    // 通过pthread_setcancelstate设置取消的状态
    // 设置为可以取消
    // pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

    // 设置为不可取消
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

    while (1)
    {
        printf("子线程1正在运行\n");
        sleep(1);
    }
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 通过调用pthread_cancel函数取消另一个线程
    sleep(3);
    pthread_cancel(thread1);

    pthread_join(thread1, NULL);

    printf("进程要退出了\n");

    return 0;
}

pthread_testcancel ⇒ 线程的取消点

线程被取消后，该线程并不是马上终止，默认情况下线程执行到取消点时才能被终止。编程时可以通过pthread_testcancel函数设置线程的取消点。
void pthread_testcancel(void);
当别的线程取消调用此函数的线程时候，被取消的线程执行到此函数时结束。

在这里插入图片描述

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

void *thread_fun(void *arg)
{
    while (1)
    {
        printf("子线程1正在运行\n");
        sleep(1);

        pthread_testcancel();
    }
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 通过调用pthread_cancel函数取消另一个线程
    sleep(3);
    pthread_cancel(thread1);

    pthread_join(thread1, NULL);

    printf("进程要退出了\n");

    return 0;
}

pthread_setcanceltype ==> 线程取消类型（是否可以被立即取消）

线程被取消后，该线程并不是马上终止，默认情况下线程执行到取消点时才能被终止。编程时可以通过pthread_setcanceltype函数设置线程是否可以立即被取消。

在这里插入图片描述

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

void *thread_fun(void *arg)
{
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

    // 设置线程取消的类型  设置为立即取消
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

    // 设置为不立即取消

    while (1)
    {
        printf("子线程1正在运行\n");
        sleep(1);

        pthread_testcancel();
    }
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, thread_fun, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    // 通过调用pthread_cancel函数取消另一个线程
    sleep(3);
    pthread_cancel(thread1);

    pthread_join(thread1, NULL);

    printf("进程要退出了\n");

    return 0;
}

线程退出清理函数

和进程的退出清理一样，线程也可以注册它退出时要调用的函数，这样的函数称为线程清理处理程序（threadcleanup handler）

注意：
1、线程可以建立多个清理处理程序
2、处理程序在栈中，故它们的执行顺序与它们注册时的顺序相反

#include <pthread.h>

void pthread_cleanup_push(void (*routine)(void *),void *arg);

void pthread_cleanup_pop(int execute);

当线程执行以下动作时会调用清理函数：

1、调用pthread_exit退出线程
2、响应其他线程的取消请求
3、用非零execute调用pthread_cleanup_pop

无论哪种情况 pthread_cleanup_pop 都将删除上一次pthread_cleanup_push调用注册的清理处理函数。

  • 注册清理函数pthread_cleanup_push
    在这里插入图片描述

  • 弹出清理函数pthread_cleanup_pop
    在这里插入图片描述

案例：验证线程调用pthread_exit函数时，系统自动调用线程清理函数

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


void mycleanup(void *arg)
{
    printf("clean up ptr = %s\n", (char *)arg);
    free((char *)arg);
}

void *thread(void *arg)
{
    /* 建立线程清理程序 */
    printf("this is new thread\n");

    char *ptr = NULL;
    ptr = (char *)malloc(100);   // 堆区开辟空间

    pthread_cleanup_push(mycleanup, (void*)(ptr));
    bzero(ptr, 100);   // 清空字符串 保证里面没有其他内容
    strcpy(ptr, "memory from malloc");

    sleep(3);
    printf("before exit\n");

    pthread_exit(NULL);

    /* 注意push与pop必须配对使用，即使pop执行不到 */
    printf("before pop\n");
    pthread_cleanup_pop(1);
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t tid;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&tid, NULL, thread, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(tid, NULL);

    printf("process is dying\n");

    return 0;
}

案例：验证线程被取消时，系统自动调用线程清理函数

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


void mycleanup(void *arg)
{
    printf("clean up ptr = %s\n", (char *)arg);
    free((char *)arg);
}

void *thread(void *arg)
{
    /* 建立线程清理程序 */
    printf("this is new thread\n");

    char *ptr = NULL;
    ptr = (char *)malloc(100);   // 堆区开辟空间

    pthread_cleanup_push(mycleanup, (void*)(ptr));
    bzero(ptr, 100);   // 清空字符串 保证里面没有其他内容
    strcpy(ptr, "memory from malloc");

    sleep(10);

    /* 注意push与pop必须配对使用，即使pop执行不到 */
    printf("before pop\n");
    pthread_cleanup_pop(1);
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t tid;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&tid, NULL, thread, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    sleep(5);
    printf("before cancel\n");
    /* 子线程响应pthread_cancel后，会执行线程处理函数 */
    pthread_cancel(tid);

    pthread_join(tid, NULL);

    printf("process is dying\n");

    return 0;
}

案例：验证调用pthread_cleanup_pop函数时，系统自动调用线程清理函数

多个清理函数的情况下，处理程序在栈中，故它们的执行顺序与它们注册时的顺序相反

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


void cleanup_fun1(void *arg)
{
    printf("in cleanup func1\n");
    printf("clean up ptr = %s\n", (char *)arg);
    free((char *)arg);
}
void cleanup_fun2(void *arg)
{
    printf("in cleanup func2\n");
}

void *thread(void *arg)
{
    /* 建立线程清理程序 */
    printf("this is new thread\n");

    char *ptr = NULL;
    ptr = (char *)malloc(100);   // 堆区开辟空间

    pthread_cleanup_push(cleanup_fun1, (void*)(ptr));
    pthread_cleanup_push(cleanup_fun2, NULL);
    bzero(ptr, 100);   // 清空字符串 保证里面没有其他内容
    strcpy(ptr, "memory from malloc");

    sleep(3);

    /* 注意push与pop必须配对使用，即使pop执行不到 */
    printf("before pop\n");
    pthread_cleanup_pop(1);

    printf("before pop\n");
    pthread_cleanup_pop(1);

    return NULL;
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t tid;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&tid, NULL, thread, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(tid, NULL);

    printf("process is dying\n");

    return 0;
}

在这里插入图片描述

多任务互斥和同步

多任务互斥和同步

1、在多任务操作系统中，同时运行的多个任务可能都需要访问/使用同一种资源
2、多个任务之前有依赖关系，某个任务的运行依赖于另一个任务

同步和互斥就是用于解决上述这两个问题的。

  • 互斥：
    • 一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。POSIX标准中进程和现场同步和互斥的方法，主要有信号量和互斥锁两种方式。
  • 同步：
    • 两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。

同步就是在互斥的基础上有顺序

互斥锁

互斥锁

1、mutex是一种简单的加锁方法来控制对共享资源的访问，mutex只有两种状态，即上锁（lock）和解锁（unlock）。
2、在访问该资源前，首先应申请mutex，如果mutex处于unlock状态，则会申请到mutex并立即lock；如果mutex处于lock状态，则默认阻塞申请者。
3、unlock操作应该由lock者进行。

在这里插入图片描述

头文件
#include <pthread.h>

销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

1、功能：销毁指定的一个互斥锁。
2、参数：mutex => 互斥锁地址
3、返回值：成功返回0，失败返回非0

初始化互斥锁

1、int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

功能：初始化一个互斥锁
返回值：成功0

参数：

mutex：指定的互斥锁
mutexattr：互斥锁的属性，为NULL表示默认属性

2、pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

互斥锁上锁1

int pthread_mutex_lock(pthread_mutex_t *mutex);

1、功能：对互斥锁上锁，若已经上锁，则调用者一直阻塞到互斥锁解锁。
2、参数：mutex => 互斥锁地址
3、返回值：成功返回0，失败返回非0

互斥锁上锁2

int pthread_mutex_trylock(pthread_mutex_t *mutex);

1、功能：对互斥锁上锁，若已经上锁，则上锁失败，函数立即返回。
2、参数：mutex => 互斥锁地址
3、返回值：成功返回0，失败返回非0

互斥锁解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);

1、功能：对指定的互斥锁解锁。
2、参数：mutex => 互斥锁地址
3、返回值：成功返回0，失败返回非0

案例：不使用互斥锁

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

int money = 10000;

void *pthread_fun1(void *arg)
{
    int get, yu, shiji;
    get = 10000;

    printf("张三正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("张三正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("张三想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    pthread_exit(NULL);
}

void *pthread_fun2(void *arg)
{
    int get, yu, shiji;
    get = 10000;

    printf("李四正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("李四正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("李四想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    pthread_exit(NULL);
}

int main()
{
    printf("主控线程正在执行\n");

    pthread_t thread1, thread2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, pthread_fun1, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    if(pthread_create(&thread2, NULL, pthread_fun2, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("主控线程：process is dying\n");

    return 0;
}

在这里插入图片描述

案例：使用互斥锁

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

int money = 10000;

// 通过互斥锁解决线程间互斥问题

// 第一步：创建互斥锁（由于两个线程操作同一个互斥锁，所以定义在全局更加方便一点）
pthread_mutex_t mymutex;

void *pthread_fun1(void *arg)
{
    int get, yu, shiji;
    get = 10000;

    // 第三步：对共享资源的操作进行上锁
    pthread_mutex_lock(&mymutex);

    printf("张三正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("张三正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("张三想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    // 第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
    pthread_mutex_unlock(&mymutex);

    pthread_exit(NULL);
}

void *pthread_fun2(void *arg)
{
    int get, yu, shiji;
    get = 10000;

    // 第三步：对共享资源的操作进行上锁
    pthread_mutex_lock(&mymutex);

    printf("李四正在查询余额...\n");
    sleep(1);
    yu = money;

    printf("李四正在取钱...\n");
    sleep(1);
    if(get > yu)
    {
        shiji = 0;
    }
    else
    {
        shiji = get;
        yu = yu - get;
        money = yu;
    }

    printf("李四想取%d元，实际取了%d元，余额为%d元\n", get, shiji, yu);

    // 第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
    pthread_mutex_unlock(&mymutex);

    pthread_exit(NULL);
}

int main()
{
    // 第二步：初始化互斥锁
    pthread_mutex_init(&mymutex, NULL);

    printf("主控线程正在执行\n");

    pthread_t thread1, thread2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&thread1, NULL, pthread_fun1, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    if(pthread_create(&thread2, NULL, pthread_fun2, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 第五步：当互斥锁使用完毕后，要销毁
    pthread_mutex_destroy(&mymutex);

    printf("主控线程：process is dying\n");

    return 0;
}

在这里插入图片描述

信号量

信号量

1、信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。
2、编程时可根据操作信号量的结果判断是否对公共资源具有访问的权限，当信号量值大于0时，则可以访问，否则将阻塞。

1、P V 原语是对信号量的操作，一次P操作使信号量sem减1，一次V操作使信号量sem加1。
2、对于P操作，如果信号量的sem值为小于等于0，则P操作就会堵塞，如果信号量的值大于0，才可以执行P操作进行减1

信号量主要用于进程或线程间的同步和互斥这两种典型情况。

1、若用于互斥，几个进程（或线程）往往只设置一个信号量
2、若用于同步操作，往往设置多个信号量，并且安排不同的初始值，来实现它们之间的执行顺序。

信号量用于互斥

在这里插入图片描述

信号量用于同步

在这里插入图片描述

信号量的初始化

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
在这里插入图片描述

信号量P操作

#include <semaphore.h>
int sem_wait(sem_t *sem);
在这里插入图片描述

#include <semaphore.h>
int sem_trywait(sem_t *sem);
在这里插入图片描述

信号量V操作

#include <semaphore.h>
int sem_post(sem_t *sem);

在这里插入图片描述

获取信号量的计数器

#include <semaphore.h>
int sem_getvalue(sem_t *sem, int *sval);

信号量的销毁

#include <semaphore.h>
int sem_destroy(sem_t *sem);
在这里插入图片描述

信号量实现互斥功能

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

#include<string.h>

// 通过信号量实现互斥操作

// 第一步：创建一个信号量
sem_t sem;

void printer(char *str)
{
    // 第三步：执行P操作
    // 由于使用信号量实现互斥，信号量的初始值设置为1，则两个线程执行P操作
    // 先执行P操作的线程继续执行，后执行P操作的阻塞等待着
    sem_wait(&sem);

    while (*str)
    {
        putchar(*str);
        fflush(stdout);
        str++;
        sleep(1);
    }

    // 第四步：执行V操作
    sem_post(&sem);
}

void *thread_fun1(void *arg)
{
    char *str1 = "hello";
    printer(str1);
}

void *thread_fun2(void *arg)
{
    char *str2 = "world";
    printer(str2);
}


int main()
{
    // 第二步：初始化信号量
    sem_init(&sem, 0, 1);

    printf("主控线程正在执行\n");

    pthread_t tid1, tid2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&tid1, NULL, thread_fun1, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    if(pthread_create(&tid2, NULL, thread_fun2, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    printf("\n");
    printf("主控线程：process is dying\n");

    // 第五步：使用完毕后销毁信号量
    sem_destroy(&sem);

    return 0;
}

在这里插入图片描述

信号量实现同步功能

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

#include<string.h>

// 通过信号量实现同步功能，如果两个线程实现同步，需要通过两个信号量

char ch = 'a';

// 第一步：创建两个信号量
sem_t sem_g, sem_p;

void * pthread_g(void *arg)
{
    while (1)
    {
        // 第四步：后执行的线程中，信号量的初始值为0的信号量，执行P操作
        sem_wait(&sem_g);

        ch++;
        sleep(1);

        // 第六步：后执行的线程执行完毕后，信号量初始值为1的信号量，执行V操作
        sem_post(&sem_p);
    }
}

void *pthread_p(void *arg)  // 此线程打印ch的值
{
    while (1)
    {
        // 第三步：先执行的线程中，信号量初始值为1的信号量，执行P操作
        sem_wait(&sem_p);

        printf("%c",ch);
        fflush(stdout);

        // 第五步：当先执行的线程执行完毕后，信号量初始值为0的信号量，执行V操作
        sem_post(&sem_g);
    }
}


int main()
{
    // 第二步：初始化信号量
    sem_init(&sem_g, 0, 0);
    sem_init(&sem_p, 0, 1);

    printf("主控线程正在执行\n");

    pthread_t tid1, tid2;

    // 通过pthread_create函数创建子线程
    if(pthread_create(&tid1, NULL, pthread_g, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    if(pthread_create(&tid2, NULL, pthread_p, NULL )  != 0)
    {
        perror("fail to pthread_create");
        exit(1);
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    printf("\n");
    printf("主控线程：process is dying\n");

    // 第七步：使用完毕后销毁信号量
    sem_destroy(&sem_g);
    sem_destroy(&sem_p);

    return 0;
}
aaxhl99
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间通信------消息队列
weixin_48487878的博客
03-31 2895
文章目录前言一、什么是消息队列？二、消息队列使用的函数1. ftok()函数2、msgget函数总结 前言 消息队列是进程间通信的最主要方法之一，相比于其他方法而言，信号队列成功克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。在多进程之间需要协同处理某个任务时能够合理的进行进程间的同步以及数据交流。 以下是本篇文章正文内容，下面案例可供参考 一、什么是消息队列？ 消息队列（Message Queue,简称MQ）是由内核管理的消息链接表，由消息队列标识符标识，标识符简称队列ID。消
Linux POSIX消息队列用于线程间通信
嵌入式大杂烩
06-10 565
在应用开发中，生产者，消费者的模型非常常见，一方产生数据并把数据放入队列中，而另一方从队列中取数据，先进先出。Linux系统中提供的消息队列一般应用于进行间通信，但也可以用于线程间通信。其中，POSIX消息队列可移植性较强，使用较广。本文介绍POSIX消息队列应用于线程间通信。例子：线程1不断给线程2发送字符串数据。应用：线程间通信/进程间通信。
共享内存和消息队列
iccoke的博客
12-28 1263
共享内存和消息队列
Linux | 进程间通信之消息队列
最新发布
khh1014173041的博客
09-07 478
消息队列是一种在分布式系统中用于异步通信的机制。它允许不同的应用程序、服务或组件之间通过发送和接收消息来实现解耦和异步通信。 消息队列的基本原理是发送者将消息发送到队列中，而接收者从队列中获取消息并进行处理。消息队列中的消息通常按照先进先出（FIFO）的顺序进行处理，确保消息的顺序性。 通常情况下多个进程可同时向一个消息队列发送消息，也可以同时从一个消息队列中接收消息。发送进程把消息发送到队列尾部，接受进程从消息队列头部读取消息，消息一旦被读出就从队列中删除。
Windows下网络编程及多线程模型
Star_ID的博客
08-30 931
Socket编程
Linux进程间通信-信号量通信进程互斥实例.pdf
07-11
Linux提供了多种IPC方式，包括管道、消息队列、共享内存、信号量等。本实例主要关注的是【信号量通信】，这是一种用于控制多个进程对共享资源访问的同步机制。 【信号量】信号量是一种特殊的变量，它可以在进程之间...
消息队列在Linux线程或进程间通信中的应用.pdf
09-06
2. **信号量**：用于同步，作为资源访问的互斥锁，控制多个进程对共享资源的访问。 3. **共享内存**：允许多个进程直接共享同一段内存，高效但需要同步控制。 4. **管道（Pipe）**：单向、先进先出的数据通道，适用...
ch6-1 Windows进程通信 线程互斥和同步1
08-03
在Windows操作系统中，进程通信和线程互斥与同步是多任务环境下的核心概念，确保了不同进程之间数据的一致性和正确性。本章节主要探讨了Windows 2000/XP及其后续版本中实现这些功能的各种机制。 首先，我们来看一下...
多线程 教程 各种锁 半成品的CAS 临界区 信号量 事件 互斥锁 队列
06-07
本教程将深入探讨多线程相关的知识点，包括各种锁机制、条件变量、半成品的CAS操作、临界区、信号量、事件、互斥锁以及队列。 **多线程**：多线程是操作系统提供的一种并发执行机制，一个进程可以包含多个线程，每...
线程间同步和通信之消息队列（动态）
08-25
7. **信号量或互斥锁**：为了保证数据的一致性和完整性，可能还需要在访问共享资源（如消息队列）时使用信号量或互斥锁进行同步。 总之，STM32 RT-thread 中的消息队列是一种强大的工具，它使得线程间的数据交换变...
windows下进程间通信的（13种方法） 转载
wjg220000的博客
08-01 535
windows下进程间通信的（13种方法） 转载
【C++】Windows下共享内存加信号量实现进程间同步通信
weixin_43729127的博客
06-13 2953
Windows下共享内存加信号量实现进程间同步通信。
Windows下进程间通信——共享内存
ypy_datou的专栏
02-07 2534
window API 共享内存 文件映射 CreateFileMapping
看了这篇文章，就别担心线程间的通信了！
Simon郎的博客
05-07 3002
线程间的通信 1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 ...
线程间通信的常用方式
zh123456_789的博客
02-17 1356
线程间通信的常用方式
消息队列实现进程间通信
laoKdx的博客
08-06 1316
消息队列，实现进程间通信
进程间通信IPC-Windows消息
春夜喜雨的专栏
03-02 1202
windows消息机制提供了相对比较完备的：消息发送、读取、超时、同步异步、异常处理(消息队列满等)、消息清理等，这些可以比较全面的支持了线程内，进程间通信的需求。 相比其它通信方法Socket、Pipe、ShareMemmory，消息机制还是完备了很多的，简化了使用的难度。
异步模式：生产者消费者模式
二进制杯莫停的博客
09-05 451
代码实现 import lombok.extern.slf4j.Slf4j; import java.util.LinkedList; public class 生产者消费者模式 { public static void main(String[] args) { MessageQueue queue = new MessageQueue(2); for (int i = 0; i < 3; i++) { int id = i; .
windows 多线程 消息队列
damenhanter的专栏
06-16 2144
Windows线程分为两种：Worker线程、GUI线程 worker线程：是指完全不牵扯到图形用户界面（GUI），纯粹做运算的线程。 GUI线程：负责建造窗口以及处理消息循环（拥有消息队列）。任何一个特定窗口的消息总是被产生这一窗口的线程抓到并处理（线程收到消息后派发给不同的窗口函数处理）。 操作系统会监控计算机上的键盘和鼠标等输入设备，为每一个输入事件（由用户操作所引
linux无亲缘关系进程间通信(互斥锁+条件变量+共享内存)
07-19
在Linux中，有多种IPC机制可以实现进程间的通信，包括管道、消息队列、信号量、共享内存和套接字等。其中，互斥锁、条件变量和共享内存是常用的进程间通信方式。 互斥锁是一种同步原语，用于保护共享资源的访问。当...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值