第三十篇，进程之间的通讯方式——内存共享，内存互斥关系——信号量，Linux下的最小资源单位——线程的详细讲解

已于 2024-10-12 09:13:10 修改
阅读量898 收藏 4
点赞数 4
分类专栏： 嵌入式C语言基础 LINUX系统编程 文章标签： c语言 linux
于 2022-03-31 04:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44651073/article/details/123860403
版权

一、进程之间的通信方式   ---  共享内存。
1、共享内存也是属于IPC对象，所以在使用共享内存之前一定要申请key值与ID号。
2、共享内存作用机制以及使用范围。
作用范围：由于共享内存是IPC对象，属于系统的资源，所以在整个系统中都可以看到IPC对象，其作用范围就是linux下任意的两个进程。
机制：任意一个进程可以将数据发送到共享内存上，另外的进程就可以访问内存上的数据。

3、实现共享内存的步骤：
1）先申请key值
   key = ftok(".",10);

2）根据申请到的key值去申请共享内存的ID号。   -->  shmget()  --> man 2 shmget
功能： allocates a System V shared memory segment
    //允许申请共享内存块

使用格式：
    #include <sys/ipc.h>
        #include <sys/shm.h>

       int shmget(key_t key, size_t size, int shmflg);

参数：
    key:  key值
    size: 共享内存的总字节数，必须是PAGE_SIZE的倍数   #define PAGE_SIZE 1024
    shmflg: IPC_CREAT|0666   --> 不存在则创建

返回值：
    成功：共享内存ID号
    失败：-1

3）根据ID号去申请共享内存的区域。  --> shmat()  --> man 2 shmat
   
    #include <sys/types.h>
    #include <sys/shm.h>

   void *shmat(int shmid, const void *shmaddr, int shmflg);

参数：
    shmid: 共享内存ID号
    shmaddr: NULL    --> 系统为你分配空间地址  99.99%
        不为NULL --> 由用户自己去分配      0.01%
    shmflg: 普通属性  -> 0

返回值：
    成功：共享内存的地址
    失败：-1

4）如何撤销空间？  --> shmdt()   --> man 2 shmdt

    #include <sys/types.h>
    #include <sys/shm.h>

   int shmdt(const void *shmaddr);

参数：
    shmaddr:共享内存的地址

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

5）删除共享内存IPC对象？   --> shmctl()   --> man 2 shmctl

    #include <sys/ipc.h>
    #include <sys/shm.h>

  int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数：
    shmid：共享内存ID号
    cmd：IPC_RMID
    buf：如果是删除，则设置为NULL

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

    例题： 使用共享内存机制，来实现进程之间的通信。

写端：
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
#include <stdio.h>

int main(int argc,char *argv[])
{
    //1. 申请key值
    key_t key = ftok(".",10);
    
    //2. 根据key值去申请共享内存的ID号
    int shmid = shmget(key,1024,IPC_CREAT|0666);
    
    //3. 根据ID号去共享内存中申请空间
    char *p = shmat(shmid,NULL,0);
    if(p == (void *)-1)
        printf("shmat error!\n");
    
    //4. 不断往共享内存中写入数据
    while(1)
    {
        fgets(p,1024,stdin);
        
        if(strncmp(p,"quit",4) == 0)
        {
            break;
        }
    }
    
    return 0;    
}


读端：
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
    //1. 申请key值
    key_t key = ftok(".",10);
    
    //2. 根据key值去申请共享内存的ID号
    int shmid = shmget(key,1024,IPC_CREAT|0666);
    
    //3. 根据ID号去共享内存中申请空间
    char *p = shmat(shmid,NULL,0);
    if(p == (void *)-1)
        printf("shmat error!\n");
    
    //4. 每隔2秒就打印一次
    while(1)
    {
        //sleep(2);
        printf("from shm:%s",p);
        
        if(strncmp(p,"quit",4) == 0)
        {
            break;
        }
    }
    
    //5. 撤销映射
    shmdt(p);
    
    //6. 删除共享内存IPC对象
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

运行结果：
如果写端将某一个数据放置到共享内存上，那么读端就会一直读取共享内存的数据，不会阻塞。   --> 数据践踏。

我们想要的目标：
发送一次    -->  打印一次
再发送一次  -->  再打印一次


二、处理共享内存互斥关系  ---   信号量。
1、什么是信号量？
信号量不是进程之间的通信方式，只是作用于进程之间的通信。
信号量通过管理空间+数据，实现进程对同一片共享内存的访问互斥关系。

信号量由于是IPC对象，所以必须要申请key值与ID号。

2、关于信号量函数接口？
1）先申请key值。
   key_t key = ftok(".",10);

2）根据key值去申请信号量的ID号。   --> semget()   --> man 2 semget
功能： semget - get a System V semaphore set identifier
    //获取信号量的ID号

使用格式：
    #include <sys/types.h>
        #include <sys/ipc.h>
        #include <sys/sem.h>

       int semget(key_t key, int nsems, int semflg);

参数：
    key:  key值
    nsems: 信号量中元素的个数    空间+数据  -> 2
    semflg: IPC_CREAT|0666  --> 不存在则创建


返回值：
    成功：信号量的ID号
    失败：-1

3）设置信号量初始值以及删除信号量。  -->   semctl()  --> man 2 semctl

使用格式：
    #include <sys/types.h>
        #include <sys/ipc.h>
        #include <sys/sem.h>

       int semctl(int semid, int semnum, int cmd, ...);

参数：
    semid： 信号量ID号
    semnum：需要操作的成员的下标     想操作空间：0   想操作数据：1
    cmd：IPC_RMID   --> 用于删除信号量
         SETVAL     --> 用于设置信号量的起始值
    ...：如果第三个参数填SETVAL，那么就要填最后一个参数，这个参数就是起始值。


例如：我想设置空间为1，数据为0，代码如何写？
semctl(semid,0,SETVAL,1);  //空间为1
semctl(semid,1,SETVAL,0);  //数据为0

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

4）如何实现信号量的p/v操作？   （p操作：1->0   v操作：0->1）     --> semop()   --->  man 2 semop

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

  int semop(int semid, struct sembuf *sops, size_t nsops);

参数：
    semid:  信号量ID号
    sops:

struct sembuf{
    unsigned short sem_num;  //需要操作的成员的下标       想操作空间：0   想操作数据：1
        short          sem_op;   //p操作/v操作                p操作：-1       v操作：1
        short          sem_flg;  //普通属性，填0
};
    nsops:   信号量操作结构体的个数  --> 1

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

例如：我想空间p操作，代码如何写？

struct sembuf space; //定义结构体变量
space.sem_num = 0;  //代表空间
space.sem_op = -1;  //代表p操作
space.sem_flg = 0;

semop(semid,&space,1);  //空间p操作

例如：我想数据v操作，代码如何写？

struct sembuf data;
data.sem_num = 1;  //代表数据
data.sem_op = 1;   //代表v操作
data.sem_flg = 0;  

semop(semid,&data,1);  //数据v操作


   例题： 已知shm/目录下的代码运行结果会出现数据践踏，请把信号量技术加入到shm/目录下的代码中，把数据践踏这个问题处理掉。
读端：

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

int main(int argc,char *argv[])
{
    //1. 申请key值
    key_t key1 = ftok(".",10);
    key_t key2 = ftok(".",20);
    
    //2. 根据key值去申请共享内存和信号量的ID号
    int shmid = shmget(key1,1024,IPC_CREAT|0666);
    int semid = semget(key2,2,IPC_CREAT|0666);
    
    //3. 根据ID号去共享内存中申请空间
    char *p = shmat(shmid,NULL,0);
    if(p == (void *)-1)
        printf("shmat error!\n");
    
    //4 设置信号量的起始值
    semctl(semid,0,SETVAL,1);  //设置空间为1
    semctl(semid,1,SETVAL,0);  //设置数据为0
    
    //5. 数据p操作
    struct sembuf data;  
    data.sem_num = 1; //数据
    data.sem_op = -1;  //p操作
    data.sem_flg = 0; //普通属性
    
    //6. 空间v操作
    struct sembuf space;
    space.sem_num = 0;  //空间
    space.sem_op = 1;  //v操作
    space.sem_flg = 0;  //普通属性
    
    //7. 每隔2秒就打印一次
    while(1)
    {
        //请问数据能不能减1？ //数据p操作
        semop(semid,&data,1); 
        
        printf("from shm:%s",p); //开车出来
        
        //车位的数量（空间）自动加1 
        semop(semid,&space,1);
        
        if(strncmp(p,"quit",4) == 0)
        {
            break;
        }
    }
    
    //8. 撤销映射
    shmdt(p);
    
    //9. 删除共享内存IPC对象
    shmctl(shmid,IPC_RMID,NULL);
    
    //10. 删除信号量
    semctl(semid,0,IPC_RMID);

    return 0;
}


写端：

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

int main(int argc,char *argv[])
{
    //1. 申请key值
    key_t key1 = ftok(".",10);
    key_t key2 = ftok(".",20);
    
    //2. 根据key值去申请共享内存和信号量的ID号
    int shmid = shmget(key1,1024,IPC_CREAT|0666);
    int semid = semget(key2,2,IPC_CREAT|0666);
    
    //3. 根据ID号去共享内存中申请空间
    char *p = shmat(shmid,NULL,0);
    if(p == (void *)-1)
        printf("shmat error!\n");
    
    //4 设置信号量的起始值
    semctl(semid,0,SETVAL,1);  //设置空间为1
    semctl(semid,1,SETVAL,0);  //设置数据为0
    
    //5. 空间p操作
    struct sembuf space;
    space.sem_num = 0;  //空间
    space.sem_op = -1;  //p操作
    space.sem_flg = 0;  //普通属性
    
    //6. 数据v操作
    struct sembuf data;  
    data.sem_num = 1; //数据
    data.sem_op = 1;  //v操作
    data.sem_flg = 0; //普通属性
    
    //7. 不断往共享内存中写入数据
    while(1)
    {
        //请问空间能不能减1？
        semop(semid,&space,1);  //空间p操作
        
        fgets(p,1024,stdin); //开车进去
        
        //车的数量（数据）自动加1。  //数据v操作
        semop(semid,&data,1); //数据v操作
        
        
        if(strncmp(p,"quit",4) == 0)
        {
            break;
        }
    }
    
    return 0;    
}


三、linux下最小资源单位。  --  线程。
1、进程与线程的区别？
假设linux是一个社会，那么进程就是一个人，线程就是一个人的一只手。
线程其实就是一个进程的内部资源。

int main()
{
    /* 进程开始 */
    xxxxx;    
    xxxxx;   --> 在进程运行过程中，可以开启很多个线程。
    xxxxx;
    xxxxx;
    return 0;
    /* 进程结束 */
}

2、线程函数接口特点？
1）由于线程函数都是封装在线程库中，所以我们是看不到源码，查看线程函数的使用格式，都是在第3手册： man 3 xxx
2）所有线程函数头文件只有一个：#include <pthread.h>

四、线程的函数接口？
1、如何在一个进程中创建一个线程？   -->  pthread_create()   --> man 3 pthread_create
功能： pthread_create - create a new thread
        //创建一个新的线程

使用格式：
  

  #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： 线程的例程函数    这个函数必须长： void *func(void *arg)
            （你想线程做什么事情，只需要把这些事情写入到这个函数中即可）
    arg：传递给线程例程函数的参数，如果不需要传递，则设置为NULL

返回值：
    成功：0
    失败：非0错误码

注意：    Compile and link with -pthread.
    //编译时要链接线程库

错误示范：gcc xxx.c -o xxx
正确示范：gcc xxx.c -o xxx -lpthread


大概：
void *func(void *arg)  //子线程的例程函数
{
    //线程开始
    ??????    --> 主线程与子线程的代码是同时运行的。
    ??????
        ??????


    //线程结束
}

int main()
{
    //进程开始

    pthread_create(xxx , xxx , func , xxx);
    //主线程
    ??????    --> 主线程与子线程的代码是同时运行的。
    ??????
    ??????

    return 0;  //进程结束
}


    例题： 尝试去创建一个子线程，看看能不能同时做两件事情。

//情况一： 子线程与主线程一起工作，子线程工作时间短，主线程工作时间长。

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

void *func(void *arg)  //线程的工作函数  arg = NULL
{
    //现在这里就是子线程
    int i;
    for(i=0;i<5;i++)
    {
        sleep(1);
        printf("child i = %d\n",i);
    }
}

int main(int argc,char *argv[])
{
    //1. 马上创建一个子线程。
    pthread_t tid;
    pthread_create(&tid,NULL,func,NULL);
    
    //2. 现在这里就是主线程
    int i;
    for(i=0;i<10;i++)
    {
        sleep(1);
        printf("parent i = %d\n",i);
    }
    
    return 0;
}

运行结果：
子线程运行5s  主线程运行10s   程序正常退出。

//情况二： 子线程与主线程一起工作，子线程工作时间长，主线程工作时间短。

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

void *func(void *arg)  //线程的工作函数  arg = NULL
{
    //现在这里就是子线程
    int i;
    for(i=0;i<10;i++)
    {
        sleep(1);
        printf("child i = %d\n",i);
    }
}

int main(int argc,char *argv[])
{
    //1. 马上创建一个子线程。
    pthread_t tid;
    pthread_create(&tid,NULL,func,NULL);
    
    //2. 现在这里就是主线程
    int i;
    for(i=0;i<5;i++)
    {
        sleep(1);
        printf("parent i = %d\n",i);
    }
    
    return 0;
}

运行结果：
主线程与子线程在5s时，一起结束了。


2、如何接合一个线程？   -->  pthread_join()   --> man 3 pthread_join
功能： pthread_join - join with a terminated thread
        //接合一个结束的线程

使用格式：
    #include <pthread.h>

       int pthread_join(pthread_t thread, void **retval);

参数：
    thread：需要接合的那个子线程的ID号
    retval：存储子线程退出值的指针，如果不关心子线程的退出状态只接合，那么就设置为NULL。

返回值：
    成功：0
    失败：非0错误码------------------------------------------------

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

void *func(void *arg)  //线程的工作函数  arg = NULL
{
    //现在这里就是子线程
    int i;
    for(i=0;i<10;i++)
    {
        sleep(1);
        printf("child i = %d\n",i);
    }
}

int main(int argc,char *argv[])
{
    //1. 马上创建一个子线程。
    pthread_t tid;
    pthread_create(&tid,NULL,func,NULL);
    
    //2. 现在这里就是主线程
    int i;
    for(i=0;i<5;i++)
    {
        sleep(1);
        printf("parent i = %d\n",i);
    }
    
    //3. 原地等待孩子的退出，接合他。
    pthread_join(tid,NULL);
    
    return 0;
} 


----------------------------------------------   

3、线程的退出？  --> pthread_exit()   --> man 3 pthread_exit
功能： pthread_exit - terminate calling thread
        //结束一个正在运行的线程

使用格式：
    #include <pthread.h>

       void pthread_exit(void *retval);

参数：
    retval： 存储着退出值的变量的地址     --> 这个退出值必须是全局变量，不能是局部变量。

返回值：无--------------------------------------------------

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

int exit_state = 50;

void *func(void *arg)
{
    int i;
    for(i=0;i<5;i++)
    {
        printf("%d\n",i);
        sleep(1);
    }
    
    //如果你想让主线程知道，你是怎么退出的，那么就得调用pthread_exit()函数。
    pthread_exit((void *)&exit_state);
}

int main(int argc,char *argv[])
{
    pthread_t tid;
    pthread_create(&tid,NULL,func,NULL);
    
    void *p = NULL;
    pthread_join(tid,&p);  //p = (void *)&exit_state
    printf("exit_state = %d\n",*(int *)p);
    
    return 0;
}


---------------------------------------------------


 

肖爱Kun
关注
专栏目录
Linux——线程大汇总！（与进程的区别及优势、创建等待及退出、共享内存、线程同步互斥量加锁解锁、互斥锁限制共享资源的访问、死锁、条件控制）
行不地上的博客
09-24 301
线程万字大汇总！（与进程的区别及优势、创建等待及退出、共享内存、线程同步互斥量加锁解锁、互斥锁限制共享资源的访问、死锁、条件控制）
笔记总结 | 线程、进程的概念和区别、进程间通信、线程间通信
大虎牙的博客
06-25 881
请你说一下进程与线程的概念，以及为什么要有进程线程，其中有什么区别，他们各自又是怎么同步的。 01 基本概念： 进程是对运行时程序的封装，是系统进行资源调度和分配的的基本单位，实现了操作系统的并发； 一个程序加载到内存后就变为进程。进程 = 程序 + 执行。线程可以理解为进程中执行的一段程序片段。 线程是进程的子任务，是CPU调度和分派的基本单位，用于保证程序的实时性，实现进程内部的并发； 线程是操作系统可识别的最小执行和调度单位。每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状.
IPC之信号量·即时通讯小程序（三）
weixin_33922672的博客
12-25 123
上次说到解决并发的问题，需要用到信号量。下面，简单复习一下。 信号量 信号量是一种变量，它只能取正整数值，对这些正整数只能进行两种操作：等待和信号。（在我的理解，信号量就是用来访问一些临界资源而设计的）用两种记号来表示信号量的这两种操作：P（semaphore variable） 代表等待（请求资源）V（semaphore variable） 代表信号（释放资源） 信号量的分类 最简单的信号...
Semaphore 信号量小解
Codegeek_jfl的博客
01-25 249
Semaphore ：和synchronized 、lock有点像，限制线程数量访问临街资源。 附上demo public class TestClass { public static void main(String[] args) { Semaphore semaphore = new Semaphore(5); new Thread(ne
Linux内核中共享资源竞争的互斥机制
最新发布
m0_65057835的博客
08-12 759
当共享的资源同时被多个需要这个资源的主体访问时（并发），会产生竞态。这里的主体可能有：中断、另一个进程、另一个cpu。需要用互斥的方式来解决竞态。
[字符驱动设备]通过引入读写信号量，实现互斥访问
chuomei5332的博客
04-27 362
说在前面的话 Linux是一个多任务操作系统，会存在多个任务共同操作同一段内存或设备的情况，这些任务可能会相互覆盖内存中的数据，进而造成内存数据混乱。造成这种现象的原因很复杂，主要有以下几个主要原因。 1） 多线程并发。 2）抢占式并发访问（2.6版本内核支持抢占，调度程序可以在任意时刻抢占正在运行的线程，从而运行其他线程）。 3）中断程序并发访问。 4）SMP(Symmetrical Multi-Processing)核间并发访问。 以多线程访问为例，当多个控制线程共享相同内存时，需要确保每个线程看到一致
【linux进程间通信(二)】共享内存详解以及进程互斥概念
杭电码农-NEO的博客
02-23 1965
本篇文章着重讲解了进程间通信的方式之一: 共享内存的基本概念,共享内存的接口使用以及它的底层原理,内附代码和图文讲解,看完就能学会!
用信号量实现共享内存互斥访问
qq_40181728的博客
08-19 512
需求：进程A对一个整数0执行1000000000次加操作 进程B对一个整数0执行1000000000次减操作 进程A，B并行执行，最后的数据结果应该是0 注意要先执行A，初始化信号量。 进程A： #include<sys/types.h> #include<sys/ipc.h> #include<sys/stat.h> #include<sys/shm.h> #include<sys/sem.h> #include<fcntl.h> #
Windows+C语言 共享内存与互斥量
ruyan1025的博客
08-18 2650
第一篇，语言生涩，大家勿喷，如有错误，望请赐教，非常感谢。 一、共享内存 1、什么是共享内存？ 共享内存，就是多个进程共用一块逻辑内存，每个进程均可对该内存进行读写，是实现进程间通信（本地通信）的一种方式。在Windows和linux平台均可实现，实现流程相似，但调用的函数有所不同，这里只记录Windows平台下的实现方法。 2、实现流程 既然名为共享内存，在使用前肯定要先向系统申请内存。以两个进...
Linux系统信号量机制互斥访问共享内存区进行进程间通信
qq_44486439的博客
05-22 562
Linux系统信号量机制互斥访问共享内存区进行进程间通信 实现代码 #include <bits/stdc++.h> #include <unistd.h> #include <sys/ipc.h> #include <sys/types.h> #include <sys/sem.h> #include <sys/wait.h> #include <sys/shm.h> using namespace std; const
Linux中的线程
zsffzb的博客
11-04 1746
1.线程的基本概念 2.线程和进程的区别 *线程的同步 线程的调度 线程的通信编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程_阳光日志-CSDN博客_多线程和多进程编程线程是什么？要理解这个概念，须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
07-07
说明：编译时加上参数 -lrt -lpthread 要不然找不到库文件
六种进程间通信方式详解
m0_53263647的博客
08-17 1890
信号的名字和编号：每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO”、“SIGCHLD”等等。信号定义在 signal.h 头文件中，信号名都定义为正整数。具体的信号名称可以使用 kill -l 来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0有特殊的应用。...............
OS知识点汇总（考研用）——第二章：进程管理（上）
qq_44709990的博客
09-11 1167
OS知识点汇总（考研用）——第二章：进程管理  本文参考于《2021年操作系统考研复习指导》（王道考研），《计算机操作系统教程》 2.进程管理 2.1 进程与线程  2.1.1 进程的概念和特征   1.进程的概念   在多道程序环境下，允许多个程序并发执行，此时它们将失去封闭性，并具有间断性及不可再现性的特征。为此引入了进程（Process）的概念，以便更好地描述和控制程序的并发执行，实现OS的并发性和共享性（最基本的两个特性）   为了使参与并发执行的程序（含数据）能独立地运行，必须为之配置一个专门的数
进程间通信——共享内存
a_struggling_monkey的博客
05-10 1096
目录 ●什么是共享内存 ●共享内存的原理 ●共享内存的特点 ●共享内存的数据结构 ●共享内存函数 ●server/client实例 ●什么是共享内存？ 两个或多个进程共享一段特定的存储区，这块存储区就叫做共享内存。进程可以将共享内存挂接到它们自己的进程地址空间中，这样一来，不同的进程就可以进行读取或修改共享内存中的数据，实现了进程间通信。 ●共享内存...
Linux进程间通信之互斥锁（共享内存实现），包括C++11的事件，信号量
阿乐的博客
04-25 3663
#pragma once #include <mutex> #include <condition_variable> #include <chrono> #include <string> #include <memory> #ifndef _WIN32 #include <unistd.h> #include <semaphore.h> #include <stdio.h> #include <fcn
linux进程间共享内存通信唤醒进程读,共享内存+互斥量实现linux进程间通信
weixin_30969157的博客
04-28 296
共享内存+互斥量实现linux进程间通信 (8页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！19.90 积分1共享内存共享内存+互斥量实现互斥量实现 linux 进程间通信进程间通信一、一、共享内存简介共享内存简介 共享内存是进程间通信中高效方便的方式之一。共享内存允许两个或更多进程访问同 一块内存，就如同 malloc() 函数向不同进程返回了指向...
进程间的通信方式——共享内存
han_shi_lei的博客
09-21 1183
共享内存指在多处理器的计算机系统中，可以被不同中央处理器（CPU）访问的大容量内存。由于多个CPU需要快速访问存储器，这样就要对存储器进行缓存（Cache）。 1.共享内存 共享内存是进程间通信中最简单的方式之一。共享内存允许两个或者多个进程访问同一块内存，就如同malloc（）函数向不同进程返回了指向一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其他进程都会察觉到这个更改。 共...
Linux线程
抚琴弹出情凋零的博客
04-17 2388
1.线程的概念 LWP：light weight process 轻量级的进程，本质任然是进程（在Linux环境下） 进程：独立地址空间，拥有PCB 线程：也有PCB，但没有独立的地址空间（共享） 区别：在于是否共享地址空间；独居（进程）， 合租（线程） Linux下：线程：最小的执行单位 进程：最小分配资源单位，可看成是只有一个线程的进程 一个进程内部可以有多个线程，默认情况下一个进程只有一个线程 内核实现都是通过clone实现的 线程也有自己的PCB 查看LWP号：ps -Lf pi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

肖爱Kun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值