Unix进程间通信 - 无名管道

Unix进程间通信方式

1.早期UNIX进程间通信方式：
  • 无名管道(pipe)
  • 有名管道(fifo)
  • 信号(signal)
2.System V IPC：
  • 共享内存(share memory)
  • 消息队列(message queue)
  • 信号灯集(semaphore set)
3.可用于本地间通信也可用于不同主机直接通过网络通信：
  • 套接字(socket)

无名管道：

进程不像线程通信可以通过全局的变量来实现，进程的资源空间都是独立私有的，没有公共可访问的资源，所以要想实现进程接的数据交换就必须通过内核提供的通信机制来完成。

  • 最简单的一种内核通信机制：无名管道

无名管道的特点

  • 只能用于具有亲缘关系的进程之间通信，亲缘关系：父子进程、父孙进程等同属于一个进程组的进程。
  • 单工的通信模式,具有固定的读端和写端。一个进程只能读管道或者写管道，不能读完管道后面又去写管道。
  • 无名管道创建时会返回两个文件描述符,分别用于读写管道。所以可以看出无名管道底层通过文件io来进行数据交互。
  • 无名管道只能通过自己创建或从父进程继承得到。

为什么无名管道只能用于有亲缘关系的进程间通信？

因为无名管道创建的时候创建的两个文件是仅仅存在于内存中的，这两个文件对文件系统不可见，也就没有文件路径。这两个文件只能通过文件描述符访问，父进程创建好后子进程可以通过继承的方式继承打开的普通文件和无名管道，而其它进程无法得到这个无名管道的文件描述符。

无名管道的创建

1
2
3
4
5
#include <unistd.h>
int pipe(int pfd[2]);
//成功时返回0,失败时返回EOF
//pfd包含两个元素的整形数组,用来保存文件描述符
//pfd[0]用于读管道: pfd[1]用于写管道,一个进程只能用到其中的一个文件描述符

无名管道的单向性：

  • 一个进程只能读或者写管道，如果要实现进程之间双向通信就需要使用两个无名管道实现。

  • 使用的时候要约定好，哪个进程读管道(访问pfd[0])哪个进程写管道(访问pfd[1])。

无名管道 - 示例：

  • 子进程1和子进程2分别往管道中写入字符串，父进程读管道内容并打印。
  • 注意父进程必须线创建无名管道，创建好管道后再创建子进程这样子进程才能把无名管道继承过去。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void) 
{
    pid_t pid1, pid2;
    char buf[32];
    int pfd[2];
    if (pipe(pfd) <0) // 创建无名管道
    {
    	perror("pipe");
        exit(-1);
    }
    
    if ((pid1 = fork()) < 0) 
    {
        perror("fork");
        exit(-1);
    }
    else if (pid1==0) //子进程1
    { 
        strcpy(buf, "I'm process1");
        write(pfd[1], buf, 32);
        exit(0);
    }
    else //父进程
    { 
        if ((pid2 = fork()) <0)
        {
            perror("fork");
            exit(-1);
        }
        else if (pid2==0)  //子进程2
        {
            sleep(1); // 睡眠是为了让子进程1先运行
            strcpy(buf, "I'm process1");
        	write(pfd[1], buf, 32);
            exit(0);
        }
        else // 父进程
        {
             wait(NULL); // 等待回收子进程1
             read(pfd[0], buf, 32); // 读完管道后管道内容自动被清除
             printf("%s\n", buf);
             wait(NULL); // 等待回收子进程2
             read(pfd[0], buf, 32);
             printf("%s\n", buf); 
        }
    }    
    return 0;
}

无名管道返回的文件和普通文件的区别

  • 无名管道文件里面的数据读完就会自动清除。
  • 无名管道文件不支持文件读写定位fseek()、lseek()。

无名管道的读写特性

读无名管道

1.写端存在：至少有一个进程绑定了此管道的写操作

  • 有数据

1.管道中数据大于进程要读的数据 : 读管道成功，read()函数返回进程要读的数据字节数。

2.管道中数据小于进程要读的数据 : 读管道成功，read()函数返回管道中的所有数据字节数。

  • 没有数据

进程读阻塞，直到其它进程向管道写入数据，该进程被唤醒。

2.写端不存在：无进程绑定写管道操作

  • 有数据

返回管道中数据，和写端存在处理一样。

  • 没有数据

read()立刻返回0，和读普通文件一样，读到文件末尾没数据了就会返回0。

一个进程在通过一个管道发数据的时候，如果数据全部发完了就关闭管道写端，这样通过读管道接收数据的进程就可以通过read()返回值为0判断数据已经全部接收完毕。

写无名管道

1.读端存在：至少有一个进程绑定了此管道的读操作

  • 有空间（存在于内存）

write返回实际写入的字节数

不保证原子操作：就是一次数据写入可能会被分成几段分段写入，每次有多少写多少，直到数据全部被写完。

  • 无空间

管道空间小于要写入的数据大小：不保证原子操作方式写入。

有多少空间就写多少内容然后进入阻塞，如果有进程从管道读了一些数据，空出一部分空间，写管道进程唤醒继续上次写数据，如果这次还没有写完，写管道进程又进入阻塞，直到要写的数据全部被写完为止才返回write()函数。

示例1 - 写管道测试系统创建的管道默认大小：

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argv, char **agrc)
{
        int count = 0;
        int pfd[2];
        char buf[1024];

        if (pipe(pfd) < 0) // 创建管道
        {
                perror("pipe");
                exit(-1);
        }

        while (1)
        {
                write(pfd[1], buf, 1024);  //循环写管道，管道没空间了进程就会被挂起
                count++;
                printf("write %dk byte\n", count);
        }

        return 0;
}

运行结果：

1
2
3
4
5
6
7
8
....
write 58k byte
write 59k byte
write 60k byte
write 61k byte
write 62k byte
write 63k byte
write 64k byte  // 由结构可知:系统创建管道的默认大小是64k byte

2.读端不存在：无进程绑定读管道操作

  • 有空间
  • 无空间

系统不允许写一个不存在读端的管道，写管道的进程会被系统异常停止（被信号结束），这种情况叫管道断裂，因为管道没有读端，向管道写数据是没有意义的。

示例2 - 写管道测试系统进程因管道断裂而退出：

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argv, char **argc)
{
        pid_t pid;
        int fpd[2];
        char buf[10];
        int status;

        if (pipe(fpd) < 0)
        {
                perror("pipe");
                exit(-1);
        }
        close(fpd[0]);  // 关闭管道的读端，使管道断裂

        pid = fork();
        if (pid < 0)
        {
                perror("fork");
                exit(-1);
        }
        else if (pid == 0) //子进程
        {
                write(fpd[1], buf, 10);
                exit(0);
        }
        else // 父进程
        {
                wait(&status);
                printf("ret = %x\n", status);
        }

        return 0;
}

运行结果：

父进程回收到子进程的程序退出码是13也就是SIGPIPE，进程被信号结束原因是管道断裂。

展开全文 >>

线程间通信 - 同步 - 信号量

线程间通信

1. 同步

  • 同步(synchronization)指的是多个任务按照约定的先后次序相互配合完成一件事情。

  • 由信号量来决定线程是继续运行还是阻塞等待

信号量只能通过三种操作来访问：

  • 初始化
  • P操作（申请资源）：任务要去访问一个资源，它不知道系统中有没有这个资源，所以他要向系统去申请代表这个资源的一个信号量。如果要申请的信号量有值资源那么就可以申请到继续运行，如果要申请的信号量没有值资源，那么就要阻塞等待这个信号量有值。
  • V操作（释放资源）：当任务不需要访问资源了或者任务产生了一个资源，这时就需要进行V操作。通知系统资源数增加了，系统就会去唤醒等待这个资源的任务。

信号量 -P / V操作

  • P(S)含义如下:
    if (信号量的值大于0) // 操作系统检查
    {
    //申请资源的任务继续运行;
    //信号量的值减一;
    }
    else
    {
    //申请资源的任务阻塞;
    }

  • V(S)含义如下:
    信号量的值加一;
    if (有任务在等待资源) // 操作系统检查
    {
    //唤醒等待的任务,让其继续运行;
    }

    在申请信号量的时候有任务有可能被阻塞，在释放信号量的时候绝对不会有任务因此阻塞。

Posix信号量

  • 无名信号量（基于内存的信号量），只存在与内存，一般用于线程通信间。
  • 有名信号量，应该在硬盘里面会对应有一个文件，用于进程通信间。

pthread库常用的信号量操作函数如下:

1
2
3
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem); // P操作获取信号量
int sem_post(sem_t *sem); // V操作释放信号量

信号量初始化：

1
2
3
4
5
6
#include <semaphore.h>
int sem_init(sem t *sem, int pshared, unsigned int val);
//成功时返回0,失败时EOF
//sem指向要初始化的信号量对象：首先要定义一个sem_t的信号量对象，把地址传进来。
//pshared o-线程间1-进程间
//val信号量初值

信号量 - P / V操作：

1
2
3
4
5
#include <semaphore.h>
int sem_wait(sem_t *sem); //P操作获取信号量
int sem_post(sem_t *sem); //V操作释放信号量
//成功时返回0,失败时返回EOF，并设置错误码一个全局的变量。
//sem指向要操作的信号量对象

线程同步 - 示例1

1. 两个线程同步读写缓冲区(生产者/消费者问题)

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
char buf[32];
sem_t sem;
void *function(void *arg);

int main(void) 
{
    pthread_t a_thread;

    if (sem_init(&sem, 0, 0) <0)  // 先初始化信号量，避免先创建了线程，线程运行去操作信号量
    {
        perror("sem_init");
        exit(-1); // 结束进程,结束线程用pthead_exit(-1);
    }

    if (pthread_create(&a_thread, NULL, function, NULL) != 0) 
    {
        printf("fail to pthraed_create");
        exit(-1);
    }
    printf("input 'quit' to exit\n");
    do{
        fgets(buf, 32, stdin);
        sem_post(&sem); // V操作释放一个信号量
    } while(strncmp(but, "quit", 4) != 0); // 有匹配到就会返回quit在buf中的开始地址
     return 0;
}

void *function(void *arg) 
{
    while (1)
    {
    	sem_wait(&sem); // P操作获取一个信号量
    	printf("you enter%d characters\n", strlen(buf));
    }
}

2. 更加严谨的同步读写缓冲区

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
char buf[32];
sem_t sem_r, sem_w;
void *function(void *arg);

int main(void) 
{
    pthread_t a_thread;
    if (sem_init(&sem_r, 0, 0) <0)// 可读信号量初始值为0
    {
    	perror("sem_init");
        exit(-1);
    }
    if (sem init(&sem-w, 0,1)<0) // 可写信号量初始值为1
    {
    	perror("sem_init");
        exit(-1);
    }
 
    if (pthread_create(&a_thread, NULL, function, NULL) != 0) 
    {
        printf("fail to pthraed_create");
        exit(-1);
    }
    printf("input 'quit' to exit\n");
    do{
        sem_wait(&sem_w); // 写缓冲区之前获取可写信号量
        fgets(buf, 32, stdin);
        sem_post(&sem_r); // 写完释放可读信号量
    } while(strncmp(but, "quit", 4) != 0); // 有匹配到就会返回quit在buf中的开始地址

    return 0;
}

void *function(void *arg)
{
    while (1)
    {
        sem_wait(&sem_r); // 读缓冲区之前获取可读信号量
    	printf("you enter%d characters\n", strlen(buf));
        sem_post(&sem_w); // 读完缓冲区释放可写信号量
    }
}

小结

  1. 信号量是和系统中一个共享资源的一个操作绑定的，用于指示该资源此时是否可以进行此种操作。
  2. P操作：获取信号量，V操作：释放信号量。
  3. 当一个线程申请一个为0的信号量是，该线程会被阻塞（被添加到该信号量的延时列表）。
  4. 当系统中某个信号量被释放时，系统会删除该信号量延时列表的第一个节点，唤醒因等待该信号量被阻塞的最高优先级的那个线程。

信号量释放规则：

信号量获取规则：

展开全文 >>

Unix进程间通信 - 有名管道

进程间通信 - 有名管道

1.有名管道的特点

  • 有一个具体的管道文件，这个文件有路径有名字，任何进程都可以通过路径加名字通过open()打开来访问管道，所以有名管道可以用于任意进程之间通信。
  • 有名管道文件类型为p。
  • 进程打开管道文件的方式：只读（进程为管道的读端）、只写（进程为写端）、可读可写（进程即时读端也是写端），不同的方式打开管道文件open()函数返回不同的文件描述符。
  • 通过文件io操作，但实际的写入内容还是存放于内存中，不是存放在存在于硬盘的管道文件中。
  • 当所有的读端和写端都关闭管道文件的时候，内存中的数据就会被释放。

Linux下七种文件类型

文件类型标识 文件类型
- 普通文件
d 目录
l 符号链接
s（伪文件） 套接字
b（伪文件） 块设备
c（伪文件） 字符设备
p（伪文件） 管道

2.有名管道的创建

1
2
3
4
5
6
#include <unistd.h>
#include <fcntl.h>
int mkfifo(const char *path, mode_t mode);
//成功返回0,时返回EOF
//path创建的管道文件路径,""代表当前路径
//mode管道文件的权限,如0666,和open()创建一个文件一样，有名管道主要关注可读、可写这两个权限

两个进程读写一个有名管道示例：

写管道进程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

int main(int argv, char **argc)
{
        int write_fifo;
        char buf[100];

        if (mkfifo("./myfifo", 0666) < 0) // 创建有名管道
        {
                perror("mkfifo");
                exit(-1);
        }

        write_fifo = open("./myfifo", O_WRONLY); // 只写方式打开有名管道
        if (write_fifo < 0)
        {
                perror("open");
                exit(-1);
        }

        while (1)
        {
                fgets(buf, 100, stdin);
                write(write_fifo, buf, strlen(buf)+1); // 写有名管道
        }
        close(write_fifo); // 关闭有名管道写端
        return 0;
}

读管道进程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

int main(int argv, char **argc)
{
        int read_pf;
        char buf[100];

        read_pf = open("./myfifo", O_RDONLY); // 只读方式打开有名管道
        if (read_pf < 0)
        {
                perror("open");
                exit(-1);
        }

        while (1)
        {
                if (read(read_pf, buf, 100) == 0)//读有名管道：无数据时阻塞等待，有数据时返回读到的数据。当read()为0表示所有的管道读端已关闭
                {
                        printf("write_fifo is close\n");
                        break;
                }
                printf("your enter: %s\n", buf);
        }
        close(read_pf);
        return 0;
}

运行结果：

小结：有名管道可以跨任意进程通信，有名管道所有写端都关闭时并且管道中没有数据了，再读管道read()会返回0。

在读管道的时候，如果管道中的数据小于预期要读的数据字节数，read()返回管道中的实际存在数据的字节数。

有名管道的数据依然是存放在内存中，硬盘中的文件系统文件是用来打开有名管道用的。

当只有读端或者只有写端的时候，进程打开open()管道会被阻塞。当管道写端和读端都存在了，读端和写端的open()才会返回。

展开全文 >>

Unix进程间通信 - 信号

Unix进程间通信 - 信号

  • 信号是在软件层次上对中断机制的一种模拟,是一种异步通信方式。

    内核向进程发送信号 - -> 进程停止当前的处理响应信号 - -> 信号操作处理完毕 - -> 进程继续执行原来的程序

  • linux内核通过信号通知用户进程,不同的信号类型代表不同的事件。

查看linux支持的信号类型：

信号的前31中是早期Unix系统继承来的，由于前31种信号不支持排队，有可能会造成信号的丢失，前31种信号也叫做不可靠信号。后31种是linux扩展的支持信号排队，又叫做可靠信号、实时信号。

  • 进程对信号有不同的响应方式：

1.缺省方式

2.忽略信号，进程可以设置忽略某些信号，不做处理

3.捕捉信号，进程可以设置某种信号到来时转而处理某一事先定义好的操作（类似于中断处理函数）

  • 常用信号

信号相关命令

kill I-signal] pid

  • 默认发送SIGTERM
  • -sig 可指定信号
  • pid指定发送对象
1
2
3
4
5
kill [-signal] pid  # 默认不带信号选项kill发送的是15)SIGTERM信号：kill pid
# 示例：
kill -9 6437   # 6437是进程号pid发9信号
kill -9 -8126  # 8126是进程组的组id发9信号
kill -9 -1     # -1代表向系统中所有进程除init进程和当前自己进程外的所有进程发9信号（一般不用）

kill：向进程发信号，从字面上翻译是“杀死“的意思，但其实是向进程发信号，原因是因为大部分信号是用于杀死一个进程。

killall [-u user | prog] （ |是或者的意思）

  • 默认发送SIGTERM

  • prog指定进程名

  • user指定用户名

1
2
killall -u linux  # 向linux用户创建的所有进程发信号，默认发送SIGTERM
killall test  # 给test这个进程发信号，默认发送SIGTERM

普通用户用kill、killall命令只允许向自己创建的进程发信号

小结：

信号可以发送给前台进程也可以发送给后台进程

信号相关的函数

发送信号：

1
2
3
4
5
6
7
#include <unistd.h>
#include <signal.h>
int kill(pid_t pid, int sig)
int raise(int sig); // 操作对象是当前进程
//成功时返回0,失败时返回EOF
//pid接收进程的进程号; 0代表同组进程;-1代表所有进程（见上：含义和shell命令的pid参数一样）
//sig信号类型

设置闹钟：

1
2
3
4
5
6
7
8
int alarm(unsigned int seconds);
//成功时返回上个定时器的剩余时间,失败时返回EOF
//seconds定时器的时间,设置为0表示停止定时器
//一个进程中只能设定一个定时器,时间到时产生SIGALRM，所以设置一个定时器时，上一个定时器就会失效

int pause(void);
//进程一直阻塞,直到被信号中断，用来让进程进入睡眠等某个信号来
//被信号中断后返回-1, errno为EINTR

示例：

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() 
{
    alarm(3);
    pause(); // 进程睡眠，直到3秒后闹钟定时到，内核向该进程发送一个定时器信号，进程回去处理SIGALARM信号，也就是结束该进程
    printf("i have been waken up\n"); // 不会被执行到
    return 0;
}

终端输出：

1
2
$./a.out
Alarm clock  # 这个信息实际上是SIGALARM信号缺省执行的打印信息

重要：alarm经常用于实现超时检测，例如：网络通信的时候。

设置信号的响应方式

1
2
3
4
5
6
7
#include <unistd.h>
#include <signal.h>
void (*signal(int signo, void (*handler)(int))(int);  // 返回一个类型为void （*func）(int)的函数指针 
//成功时返回原先的信号处理函数,失败时返回SIG-ERR
//signo要设置的信号类型
//handler指定的信号处理函数:SIG-DFL代表缺省方式;
//SIG_IGN代表忽略信号;

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//头文件省略
void handler (int signo) 
{
    if (signo == SIGINT) 
    {
    	printf("i have got SIGINT\n"); // 由于SIGINT信号的默认处理是结束进程，被本本函数替换，所以进程不用终止，会循环进入睡眠、醒来
    }
    else if (signo = SIGQUIT) 
    {
    	printf("i have got SIGQUIT\n");
    }
}
       
int main() 
{
    signal(SIGINT, handler);
    signal(SIGQUIT, handler);
    while (1)
    {
        pause(); // 等到信号来，通过信号类型处理不同的信号服务函数
    }
	return 0;
}

小结：

kill/raise函数是向进程发信号

alarm函数是给进程设置定时器，定时到了，内核会给进程发送SIGALARM信号

signal函数将一个信号类型和某个处理函数绑定

展开全文 >>

System V IPC对象 - 共享内存

System V IPC对象 - 共享内存

System V IPC对象：

  • 相对unix中linux引入的。

  • IPC对象包含:共享内存、消息队列和信号灯集。

  • 每个IPC对象有唯一的ID，创建的时候返回给调用者。

  • IPC对象创建后一直存在,直到被显式地删除，和管道不同管道在所有的读端和写端都关闭的时候就会自动删除。

  • 每个IPC对象有一个关联的KEY，IPC对象的属性，不同的进程可以通过KEY值来找到和打开对象。

只有创建该IPC对象的进程才可见IPC对象的ID，其它进程不可见。每个IPC对象在创建的时候需要指定一个KEY值，把KEY值和该IPC对象关联起来，其他进程就可以通过这个KEY来找到这个IPC对象，如果KEY值被设置成0代表该IPC对象是进程私有的。为避免用户自己指定的KEY值会重复，系统提供一个专门的函数产生KEY值。

查看系统中创建的IPC对象：

ipcs

删除系统中创建的一个IPC对象：

ipcrm […]

IPC对象创建、使用流程：

生成key值函数：

key值生成原理：用ftok()函数第一个参数“文件在文件系统的i节点值”和第二个参数proj_id的低八位移位生成key值。proj_id必须是非零值，实际常指定一个字符常量。

1
2
3
4
5
6
#include <sys/types.h>
#include <sys/ipc.h>
key_ t ftok(const char *path, int.proj_id);  
//成功时返回合法的key值,失败时返回EOF
//path存在且可访问的文件的路径
//proj_id用于生成key的数字,不能为0

System V IPC-ftok-示例：

要想不同的进程使用同一个IPC对象，进程在ftok()创建key值时传的参数必须一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
nt main(int argc, char *argv[) 
{
    key_t key;
    if ((key = ftok(".", 'a')) == -1)
    {
        perror("ftok");
    	exit(-1);
    }
    
    ....
}

共享内存

共享内存是进程直接读写内核空间的内存进行进程之间数据交换，而其他IPC对象机制是在内核内存创建一块空间，数据要同步到进程自己的内存空间。

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

  • 共享内存在内核空间创建,可被进程映射到用户空间访
    问,使用灵活。

  • 由于多个进程可同时访问共享内存,因此需要同步和互
    斥机制配合使用。

共享内存使用步骤

  • 创建/打开共享内存
  • 映射共享内存,即把指定的共享内存映射到进程的地址
  • 空间用于访问
  • 读写共享内存
  • 撤销共享内存映射
  • 删除共享内存对象

共享内存创建：

1
2
3
4
5
6
#include <sys/ipc.h>
Hinclude <sys/shm.h>
int shmget(key_t key, int size, int shmflg);
//成功时返回共享内存的id,失败时返回EOF
//key和共享内存关联的key, IPC-PRIVATE或ftok生成
//mfig共享内存权限标志位IPC_CREAT|0666

共享内存创建 - shmget - 示例1
要求:创建一个私有的共享内存,大小为512字节,权限
为0666

1
2
3
4
5
6
int shmid;
if ((shmid =shmget(IPC_PRIVATE, 512, 0666)) <0) //私有类型的一定是新创建的：shmflg不需要指定IPC_CREAT位只需指定权限位
{
    perrorl("shmeget");
    exit(-1);
}

共享内存创建 - shmget - 示例2
要求:创建/打开一个和key关联的共享内存,大小为1024
字节,权限为0666

1
2
3
4
5
6
7
8
9
10
11
12
13
key_t key;
int shmid;
if ((key = ftok(".", 'm')) == -1) // 所有想使用同一个共享内存的进程传入的参数必须一致，生成的key才会一样
{
    perror("ftok");
    exit(-1);
}

if ((shmid = shmget(key, 1024, IPC_CREAT |0666)) < 0) // IPC_CREAT：如果key值不存在绑定的共享内存则创建否则返回已绑定的共享内存id
{
	perror("shmget");
    exit(-1);
}

所有进程使用共享内存之前都要运行上面一模一样的代码，第一个运行这段代码的进程是正真创建共享内存，后面运行的代码是通过key找到共享内存shmid并不是创建一个新的，因为第一个进程已经把key和这个共享内存绑定了。shmget函数发现第一个参数key已经绑定有一个共享内存了就会直接返回这个共享内存的id。

小结：
共享内存效率最高没有内存拷贝，进程直接读写内核里面的内存。
由于共享内存可以被多个进程访问，所以需要用同步和互斥机制配合对共享内存访问。

1.共享内存映射 - shmat

1
2
3
4
5
6
7
#include <sys/ipc.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
//成功时返回映射后的地址,失败时返回(void *)-1
//shmid要映射的共享内存id
//shmaddr映射后的地址, NULL表示由系统自动映射,程序通常不用关系内存的所在的首地址，和malloc一样只关心这段申请内存的长度
//shmflg标志位0表示可读写; SHM-RDONLY表示只读
  • 通过指针访问共享内存,指针类型取决于共享内存中存 放的数据类。

例如:在共享内存中存放键盘输入的字符串

1
2
3
4
5
6
7
8
9
10
char *addr;
int shmid;
... // 省略共享内存创建过程
if ((addr = (char *)shmat(shmid, NULL, 0)) == (char *)-1) // 传入NULL由系统自动分配首地址然后把共享内存映射到首地址
{
    perror("shmat");
    exit(-1);
}
fgets(addr, N, stdin);
...

2.共享内存撤销映射 - shmdt

1
2
3
4
5
6
#include <sys/ipc.h>
#include <sys/shm.h>
int shmdt(void *shmaddr);
//成功时返回0,失时返回EOF
//不使用共享内存时应撤销映射
//进程结束时自动撤销

3.共享内存控制 - shmctl

1
2
3
4
5
6
7
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//成功时返回0,失败时返回EOF
//shmid要操作的共享内存的id
//cmd要执行的操作IPC_STAT获取共享内存属性、 IPC_SET设置共享内存属性、 IPCRMID删除一个共享内存id
//uf保存或设置共享内存属性的地址

4.共享内存使用的注意事项

每块共享内存大小有限制

1
2
ipcs -1
cat /proc/sys/kernel/shmmax # 此文件存放共享内存的最大值的属性

共享内存删除的时间点

shmct(shmid, IPC-RMID, NULL) 添加删除标记，正真删除内存要满足共享内存被标记删除并且所以的进程都取消了对这块空闲内存的地址映射。struct shmid_ds共享内存结构体中nattach变量用于记录共享内存被多少个进程地址映射了。消息队列和信号灯和共享内存不一样调用删除函数就直接删除。

查看ips对象可占用内存最大值：

小结：
1.shmat：共享内存映射到进程内地址，会返回一个代表这块共享内存的首地址地址
2.shmdt：取消共享内存地址映射，传入共享内存的首地址
3.shmctl：可以通过id获取一块共享内存的属性、设置共享内存属性、删除共享内存
4.共享存储的访问就是通过指针，要读写什么类型的数据就把指针转换成该类型的数据

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发