Linux的系统编程-进程通信

IPC：进程间通信，通过内核提供的缓冲区进行数据交换的机制。

方式：

  1. pipe 管道—最简单
  2. fifo 有名管道
  3. mmap 文件映射共享IO—速度最快
  4. 本地socket 最稳定
  5. 信号—携带信息量最小
  6. 共享内存—用特定API申请的一块内存，进程退出，其他进程仍可访问这块内存
  7. 消息队列

1 使用pipe进行父子进程间通信

1
2
#include <unistd.h>
int pipe(int pipefd[2]);//pipefd文件读写描述符，0---读；1---写；返回值：成功返回0，失败返回-1

常见通信方式：单工（广播）；半双工（同一个时刻，数据只能往一个方向发，对讲机）；全双工（打电话）。

管道：半双工

父子进程通信：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <unistd.h>
int main(){
    int fd[2];
    pipe(fd);
    pid_t pid=fork();
    if(pid==0){
        //son
        write(fd[1],"hello",5);
    }else if(pid>0){
        //parent
        char buf[12]={0};
        int ret = read(fd[0],buf,sizeof(buf));
        if (ret>0){
            write(STDOUT_FILENO,buf,ret);
        }
    }
    return 0;
}

管道实例：ps aux|grep bash

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
#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd[2];
    pipe(fd);

    pid_t pid = fork();
    if(pid == 0){
        //son 
        //son -- > ps 
        //关闭 读端
        close(fd[0]);
        //1. 先重定向
        dup2(fd[1],STDOUT_FILENO);//标准输出重定向到管道写端（获取输出的内容，写入管道）
        //2. execlp 
        execlp("ps","ps","aux",NULL);
    }else if(pid > 0){
        //parent
        //关闭写端
        close(fd[1]);
        //1. 先重定向，标准输入重定向到管道读端(读取输入的内容)
        dup2(fd[0],STDIN_FILENO);
        //2. execlp 
        execlp("grep","grep","bash",NULL);
    }
    return 0;
}

读管道：

  1. 若写端全部关闭—read读到0，相当于读到文件末尾

  2. 若写端没有全部关闭

    有数据—read读到数据

    没有数据–read阻塞，fcntl函数可以更改非阻塞

写管道：

  1. 若读端全部关闭—会产生一个13号信号SIGPIPE，程序异常终止；

  2. 若读端未全部关闭

    管道已满—write阻塞

    管道未满—write正常写入

计算管道大小：

​ ulimit -a 查看上限512*8

​ long fpathconf(int fd,int name);

管道优劣：

  • 优点：简单，相比信号，套接字实现进程间通信，简单很多。
  • 缺点：1. 只能单向通信，双向通信需建立两个管道。

​ 2. 只能用于父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决。

2 使用pipe进行兄弟进程间通信

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
    int fd[2];
    pipe(fd);
    pid_t pid;
    int n =2,i = 0;
    //创建两个子进程
    for(i = 0; i < n ; i ++){
        pid = fork();
        if(pid == 0){
            break;//不让子进程创建子进程
        }
    }

    //i = 0 ,代表兄长，1 - 代表弟弟，2- 父亲
    if(i == 0){
        //兄长进程
        //1. 关闭读端
        close(fd[0]);
        //2. 重定向
        dup2(fd[1],STDOUT_FILENO);
        //3. 执行 execlp
        execlp("ps","ps","aux",NULL);
            
    }else if(i == 1){
        //弟弟 
        //1. 关闭写端
        close(fd[1]);
        //2. 重定向
        dup2(fd[0],STDIN_FILENO);
        //3. 执行ececlp
        execlp("grep","grep","bash",NULL);

    }else if(i == 2){
        //parent 
        //父亲需要关闭读写两端
        close(fd[0]);
        close(fd[1]);
        //回收子进程
        wait(NULL);
        wait(NULL);
    }
    return 0;
}

3 使用fifo进行无血缘关系的进程间通信

FIFO 有名管道，实现无血缘关系间的管道通信

通过队列实现，内核会针对fifo文件开辟一个缓冲区，操作fifo文件，可以操作缓冲区，实现进程间通信–实际上就是文件读写。

1
2
3
$ mkfifo myfifo 命令创建
或
int mkfifo(const char *pathname, mode_t mode);

fifo读

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out fifoname\n");
        return -1;
    }
    printf("begin oepn read...\n");
    int fd = open(argv[1],O_RDONLY);
    printf("end oepn read...\n");
    
    char buf[256];
    int ret;
    while(1){
        //循环读
        memset(buf,0x00,sizeof(buf));
        ret = read(fd,buf,sizeof(buf));
        if(ret > 0){
            printf("read:%s\n",buf);
        }
    }

    close(fd);
    return 0;
}

fifo写

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc,char * argv[])
{
    if(argc != 2){
        printf("./a.out fifoname\n");
        return -1;
    }
    
    // 当前目录有一个 myfifo 文件
    //打开fifo文件
    printf("begin open ....\n");
    int fd = open(argv[1],O_WRONLY);
    printf("end open ....\n");
    //写
    char buf[256];
    int num = 1;
    while(1){
        memset(buf,0x00,sizeof(buf));
        sprintf(buf,"xiaoming%04d",num++);
        write(fd,buf,strlen(buf));
        sleep(1);
        //循环写
    }
    //关闭描述符
    close(fd);
    return 0;
}

open注意：打开fifo文件的时候，read端会阻塞等待write端open，同理，write端也会阻塞等待read端open。

4 mmap函数的使用

把文件中的一段内容映射到内存中的映射区，操作内存

1
2
3
4
5
#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

int munmap(void *addr, size_t length);

创建映射区

void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

○ addr 传NULL

○ length 映射区的长度

○ prot

  • PROT_READ 可读
  • PROT_WRITE 可写

○ flags

  • MAP_SHARED 共享的，对内存的修改会影响到源文件
  • MAP_PRIVATE 私有的

○ fd 文件描述符，open打开一个文件

○ offset 偏移量

  • 成功 返回 可用的内存首地址
  • 失败 返回 MAP_FAILED

释放映射区

int munmap(void *addr, size_t length);

○ addr 传mmap的返回值

○ length mmap创建的长度

  • int munmap(void *addr, size_t length);
  • mmap共享映射区

○ 返回值

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 <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

int main()
{
    int fd = open("mem.txt",O_RDWR);//创建并且截断文件
    //int fd = open("mem.txt",O_RDWR|O_CREAT|O_TRUNC,0664);//创建并且截断文件

    ftruncate(fd,8);   
    //创建映射区
   char *mem = mmap(NULL,20,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    //char *mem = mmap(NULL,8,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);

    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    close(fd);
    //拷贝数据
    strcpy(mem,"helloworld");
//    mem++;
    //释放mmap
    if(munmap(mem,20) < 0){
        perror("munmap err");
    }
    return 0;
}

mmap九问：

  1. 如果更改mem变量的地址，释放的时候munmap，传入mem还能成功吗？不能！！

  2. 如果对mem越界操作会怎么样？文件的大小对映射区操作有影响，尽量避免。

  3. 如果文件偏移量随便填个数会怎么样？offset必须是 4k的整数倍

  4. 如果文件描述符先关闭，对mmap映射有没有影响？没有影响

  5. open的时候，可以新创建一个文件来创建映射区吗？不可以用大小为0的文件

  6. open文件选择O_WRONLY，可以吗？ 不可以： Permission denied

  7. 当选择MAP_SHARED的时候，open文件选择O_RDONLY，prot可以选择 PROT_READ|PROT_WRITE吗？Permission denied ，SHARED的时候，映射区的权限<= open文件的权限

  8. mmap什么情况下会报错？很多情况

  9. 如果不判断返回值会怎么样？ 会死的很难堪！！

5 mmap函数创建匿名映射区的方法

父子进程通信(利用匿名映射区)：

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

int main()
{
    //创建内存映射区
    int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);
	
    //是否创建成功
    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
	
    //创建子进程
    pid_t pid = fork();

    //针对父子进程处理
    if(pid == 0 ){
        //son 
        *mem = 101;
        printf("child,*mem=%d\n",*mem);
        sleep(3);
        printf("child,*mem=%d\n",*mem);
    }else if(pid > 0){
        //parent 
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 10001;
        printf("parent,*mem=%d\n",*mem);
        wait(NULL); //回收子进程
    }

    munmap(mem,4);
    return 0;
}

6 mmap函数进行有血缘关系的进程间通信

父子进程通信（利用文件）：缺点：用了一个文件，并没用到文件内容

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

int main()
{
    // 先创建映射区
    int fd = open("mem.txt",O_RDWR);
    //int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
    
    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    
    // fork子进程
    pid_t pid = fork();

    // 父进程和子进程交替修改数据
    if(pid == 0 ){
        //son 
        *mem = 100;
        printf("child,*mem = %d\n",*mem);
        sleep(3);
        printf("child,*mem = %d\n",*mem);
    }
    else if(pid > 0){
        //parent
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 1001;
        printf("parent,*mem=%d\n",*mem);
        wait(NULL);//回收子进程
    }

    munmap(mem,4);
    close(fd);
    return 0;
}

7 mmap函数进行无血缘关系的进程间通信

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
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

typedef struct  _Student{
    int sid;
    char sname[20];
}Student;

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out filename\n");
        return -1;
    }
    
    // 1. open file 
    int fd = open(argv[1],O_RDWR|O_CREAT|O_TRUNC,0666);
    int length = sizeof(Student);

    ftruncate(fd,length);

    // 2. mmap
    Student * stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    
	//判断返回值
    if(stu == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    int num = 1;
    // 3. 修改内存数据
    while(1){
        stu->sid = num;
        sprintf(stu->sname,"xiaoming-%03d",num++);
        sleep(1);//相当于没隔1s修改一次映射区的内容
    }
    // 4. 释放映射区和关闭文件描述符
    munmap(stu,length);
    close(fd);

    return 0;
}

展开全文 >>

Linux的基础语法

###1 vi编辑器

  • 命令行模式
  • 末行模式
  • 编辑模式

编辑器操作：
【[n]x】删除光标位置后面n个字符
【[n]X】删除光标位置前面n个字符
【D】删除光标所在位置后面到行尾的所有字符
【[n]dd】删除光标所在行及下面n行 剪切
【p】在光标下一行粘贴
【[n]yy】复制光标所在行及下面n行
【dG】删除光标所在行到文件结尾
【J】合并光标所在行和下一行 中间用空格连接
【.】执行上一次命令行操作
【u】撤销

编辑器定位：
【ctrl+b】回滚 行号减小
【ctrl+f】前滚 行号增加
【gg】定位在文件第一行行首
【G】定位在文件最后一行行首
【/.】查找任意一个字符
【/*】查找任意多个字符

编辑器替换：
【r】替换光标所在位置的字符
【:r 文件名】在光标当前行的下一行插入一个文件 每次添加只能添加一个文件
【:s/a/b/g】将光标所在行的a替换为b
【:g/a/s//b/g】将文件中所有a替换为b
【:n1,n2s/a/b/g】将行区间n1到n2的行中所有的a替换为b

编辑器设置：
【:set ic】搜索时不区分大小写
【:set noic】搜索时区分大小写

2 GCC编译器

gcc 整个编译过程

hello.c

gcc -E hello.c 预处理，头文件展开，宏替换 得到 hello.i

gcc -S hello.i 生成汇编代码 hello.s

gcc -c hello.s 将汇编编译成二进制文件 hello.o

ld 链接，得到可执行文件 a.out

gcc参数

直接通过gcc hello.c 也能直接生成a.out文件

-I ./include/包含头文件路径

-o app.out 指定编译出来的可执行文件的名字，运行是 ./app.out

-L 包含库路径

-l指定库名 libxxx.a|so , -lxxx

-g 加上gdb调试信息

-Wall 显示更多的警告

-lstdc++编译c++代码

-O1或 -O2或 -O3 优化代码

gcc hello.c -I./include/ -D DEBUG -o app -g -Wall -O1

g++编译

g++ hello.cpp == gcc hello.cpp -lstdc++ -o a.out 最后都能./a.out

3 静态库

linux下静态库以.a结尾 ——-windows下静态库以.lib结尾

编译的时候编译成源码，存放在内存中的代码段

优点：执行快；发布应用时不需要发布库

缺点：执行程序体积会变大；库变更时需要重新编译应用

使用：编译时需要加静态库名（含路径），-I包含头文件（大写的i），-L包含库路径，-l指定库名（库名是libCalc时，写作-lCalc:gcc main.c -o app -I include/ -L lib/ -lCalc

制作静态库步骤：

  1. 生成.o gcc -c *.c -I ./include

  2. 打包.o文件 ar rcs libxxx.a *.o

  3. 将头文件与库文件一起发布，移动到lib文件夹下：mv libCalc.a ../lib/

4 动态库(共享库)，首选

linux下共享库以.so结尾

优点：执行程序体积小，当很多应用程序都要用同个库的时候优势明显；库变更时，一般不需要重新编译应用

缺点：执行时需要加载动态库，相对而言，比静态库慢；发布应用时需要同时发布动态库

制作动态库步骤：

  1. 生成.o，关键参数-fPIC（与位置无关）：gcc -fPIC -c *.c -I ../include/
  2. 打包 -shared,-o指定库名，后面加上原材料*.o：gcc -shared -o libCalc.so *.o
  3. 发布：将动态库移动到lib文件夹下：mv libCalc.so ../lib/

使用动态库的方法（略麻烦）：

使用编译的时候与静态库一样，需要配置库的路径，保证ld链接器能够加载

  1. 拷贝或链接到/lib,/usr/lib这样的系统库目录
  2. 设置环境变量，LD_LIBRAY_PATH，export LD_LIBRAY_PATH=libpath:$LD_LIBRAY_PATH
  3. 修改/etc/ld.so.conf,Idconfig 这两步都需要root权限

法1：拷贝到系统库目录下，不允许！

gcc main.c -o newapp -I include/ -L lib/ -lCalc生成可执行文件newapp

./newapp运行时报错

查看可执行文件的链接：ldd newapp 提示libCalc.so是无法找到

将我们的libCalc.so文件的软链接放到系统能找到的库路径，源文件要用绝对路径：

sudo ln -s /home/dingjing/study/Calc/lib/libCalc.so /lib/libCalc.sp

再次查看可执行文件的链接：ldd newapp提示libCalc.so找到了

法2：修改LD_LIBRAY_PATH环境变量，将库所在的路径，添加到环境变量中，用冒号分隔，不推荐！

export LD_LIBRAY_PATH = /home/dingjing/study/Calc/lib/ : $LD_LIBRAY_PATH

法3：修改/etc下的配置文件ld.so.conf，将库路径添加到该文件中，推荐！！

sudo vi /etc/ld.so.conf 把/home/dingjing/study/Calc/lib/写入文件的新的一行

sudo ldconfig -v加-v显示加载过程（是小写的L）

5 makefile

优点：一次编写，终身受益

命名规则：makefile、Makefile

三要素：

目标：希望生成的目标文件

依赖：通过什么文件去生成

规则命令：怎么去生成

写法：

目标:依赖

tab键规则命令

第一版：

1
2
3
app:main.c add.c sub.c div.c mul.c

​	gcc -o app -I ./include main.c add.c sub.c div.c mul.c

如果更改其中一个文件，所有源码都重新编译

可以考虑编译过程分解，现生成.o文件，使用.o文件生成结果。这样，如果一个.c文件发生变化，只需要把变化的文件生成.o文件

第二版：

1
2
3
4
5
6
7
8
9
10
11
12
app:main.o add.o sub.o div.o mul.o
	gcc -o app -I ./include main.o add.o sub.o div.o mul.o
main.o:main.c
	gcc -c main.c -I ./include
add.o:add.c
	gcc -c add.c -I ./inlcude
sub.o:sub.c
	gcc -c sub.c -I ./include
mul.o:mul.c
	gcc -c mul.c -I ./inlcude
div.o:div.c
	gcc -c div.c -I ./include

第三版：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#新建变量ObjFiles 定义目标文件
ObjFiles=main.o add.o sub.o div.o mul.o
#目标文件用法$(var) 直接翻译 直译
app:$(ObjFiles)
	gcc -o app -I ./include main.o add.o sub.o div.o mul.o
main.o:main.c
	gcc -c main.c -I ./include
add.o:add.c
	gcc -c add.c -I ./inlcude
sub.o:sub.c
	gcc -c sub.c -I ./include
mul.o:mul.c
	gcc -c mul.c -I ./inlcude
div.o:div.c
	gcc -c div.c -I ./include

隐含规则：默认处理第一个目标

第四版：

两个函数：

  • wildcard文件匹配
  • patsubst内容替换

自动变量：只能在规则中出现

  • $@代表目标
  • $^ 代表全部依赖
  • $< 代表第一个依赖
  • $?代表第一个变化的依赖
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
#get all .c files
SrcFiles=$(wildcard *.c)

#all .c files-->.o files
ObjFiles=$(patsubst %.c,%.o,$(SrcFiles))

all:app app1

#目标文件用法 $(var) 直接翻译 直译
app1:$(ObjFiles)
	gcc -o $@ -I ./include $(SrcFiles)
app2:$(ObjFiles)
	gcc -o $@ -I ./include $(SrcFiles)
	
#模式匹配规则
%.o:%.c
	gcc -o $@ -c $< -I ./include
	
test:
	@echo $(SrcFiles)
	@echo $(ObjFiles)

#定义伪目标，防止有歧义
.PHONY:clean all

clean:
	@rm -f *.o #或者 -@rm *.o
	@rm -f app1 app2

@在规则前代表不输出该条规则命令

规则前的减号 - 代表该条规则报错，仍然继续执行

make -f makefile1指定makefile文件

6 gdb调试

使用gdb：编译的时候加-g参数

启动 gdb app

在gdb里启动程序：

r 或者 run：运行

start：停留在main函数，分步调试，敲n，表示next，执行下一条指令，之后回车就行

s 或者 step：分步执行，进入到函数内部执行，但进不去库函数

quit：退出gdb调试

设置运行参数

set args 521 518：设置启动参数 或run 521 518

set argv[1]="12"

显示10行代码

l 或 list：默认显示10行代码，回车，再显示接下来的10行代码；list main.c:1从第一行开始显示

断点

b 17或者 break 17：给17行设置断点，run的时候直接到断点处

b main.c:17:给main.c文件的第17行设置断点

b main ：给main函数设置断点

info b：查看设置了哪些断点

d 4 和 del 6：删除断点

c代表continue，程序继续执行到下一个断点

b 32 if i==1:条件断点，当i==1的时候，进行这个断点

查看变量

p argc 和 print i都可以查看变量的值，用法相同

ptype i 查看变量的类型

跟踪变量

display argc:跟踪变量的值，每执行一次命令，显示跟踪的变量的值

info display:查看跟踪的变量编号

undisplay 1:放弃跟踪1号变量

调试core文件（gdb跟踪core）

core—-案发现场

ulimit -c unlimited：设置生成core，大小可以无限大

./app:报错：段错误（核心已转储）

ls -lrt:出现一个core文件

gdb app core:告诉你程序是哪行出错了

where：再次告诉你是哪行出错了

设置core文件格式：

sudo vi /proc/sys/kernel/core_pattern

core-%e-%t

或：

sudo echo "core-%e-%t">/proc/sys/kernel/core_pattern

系统API和库函数的关系

7 文件IO操作

open

man 2 open

1
2
3
4
5
6
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

pathname：文件名

flags：

1
2
3
4
5
6
7
8
9
//必选项：
O_RDONLY:只读
O_WRONLY：只写
O_RDWR：读写

//可选项：
追加O_APPEND 
创建O_CREAT:mode权限位(mode & ~umask) 
非阻塞O_NONBLOCK

返回值：open返回最小的可用文件描述符；失败返回-1

close

1
int close(int fd);

fd：open打开的文件描述符

返回值：成功返回0，失败返回-1，设置errno

read

1
ssize_t read(int fd,void*buf,size_t count);

fd:文件描述符

buf:缓冲区

count:缓冲区大小

返回值：失败返回-1，设置errno；成功返回读到的大小；0代表读到文件末尾

write

1
ssize_t write(int fd,const void *buf,size_t count);

fd:文件描述符

buf:缓冲区

count:缓冲区大小

返回值：失败返回-1，设置errno；成功返回写入的字节数；0代表未写入

open/close 可以实现touch功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
#include<sys/types.h>
#include<sys/fcntl.h>
#include<unistd.h>

int main(int argc,char *argv[])
{
	if(argc!=2){

		printf("./a.out filename\n");
		return -1;
	 }

	int fd = open(argv[1],O_RDONLY|O_CREAT,0666);
	close(fd);
	return 0;
}

read/write 查看文件内容，可以实现cat功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<stdio.h>
#include<unistd.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>

int main(int argc,char *argv[]){
	if(argc!=2){
		printf("./a.out filename\n");
		return -1;
	}
	int fd = open(argv[1],O_RDONLY);
	//读 输出到屏幕
	char buf[256];
	int ret = read(fd,buf,sizeof(buf));
	write(STDOUT_FILENO,buf,ret);
	close(fd);
	return 0;
}

lseek

1
off_t lseek(int fd,off_t offset,int whence);

fd:文件描述符

offset:偏移量

whence: SEEK_SET文件开始的位置；SEEK_CUR当前位置；SEEK_END结尾

返回值：成功，返回当前位置到开始的长度；失败返回-1，设置errno

打开一个文件，输入一段内容，然后读取一下该文件的内容，输出到屏幕

lseek 改变读写位置，计算大小，拓展文件（至少写一次）

阻塞fcntl

read函数在读设备、管道、网络的时候

输入输出设备对应/dev/tty

1
int fcntl(int fd,int cmd,...)

fcntl决策函数，设置非阻塞，就3步，3行代码

1
2
3
int flags = fcntl(fd,F_GETFL);//获取原来的样子
flags |= O_NONBLOCK;//与非阻塞或一下
fcntl(fd,F_SETFL,flags); //设置一下

errno

dup2

主要用于文件重定向

1
int dup2(int oldfd,int newfd);//关闭新的fd，并将新的fd指向旧的fd

dup

用于复制，便于恢复现场

8 文件操作函数

stat:获取inode信息

access：按有效用户ID和有效组ID测试，追述符号链接（可读、可写、可执行、测试文件是否存在）

chmod：修改文件权限

chown：修改用户 及 组

truncate：截断文件长度为指定长度

rename：重命名

link:

link：硬链接

symlink：软链接

readlink：读取符号链接本身内容，得到链接指向的文件名

unlink：删除符号链接 或 硬链接计数

getcwd：获得当前目录

chdir：改变进程工作目录

mkdir：创建目录

rmdir：删除目录

opendir：打开目录

readdir：读目录

rewinddir：把目录指针恢复到起始位置

telldir：获取目录读写位置

seekdir：修改目录读写位置

closedir：关闭目录

展开全文 >>

Linux的系统编程-进程控制

1 了解进程相关的概念

程序：

编译好的二进制文件；

进程：
  • 运行着的程序；
  • 程序员的角度：运行一系列指令的过程
  • 操作系统的角度：分配系统资源的基本单位
区别：
  • 程序占用磁盘，不占用系统资源；内存占用系统资源；
  • 一个程序对应多个进程，一个进程对应一个程序；
  • 程序没有生命周期，进程有生命周期；
单通道和多通道设计：

时间片轮转，执行速度ns级别，人只能感受到ms级别的变化，宏观上并发，微观上串行

CPU和MMU（了解）

存储介质：网络—–硬盘—–内存—–高速缓存cache—–寄存器

CPU：1预取指令—–2译码—–3执行

MMU（位于CPU内）：

1虚拟内存和物理内存的映射

将虚拟内存地址和物理内存地址进行 绑定或叫做映射，比如有个变量i=10存放在物理内存中，先看一下虚拟地址是啥，MMU找到对应的物理地址，取出该数。

2设置修改内存访问级别

0>1>2>3

用户控件映射到物理内存是独立的。

内核区是映射到同一块地址。

进程的状态转换

初始、就绪、运行、挂起、终止

就绪状态———————-（获得CPU）——————–运行状态

运行状态—————–（获得的时间片结束）————就绪状态

运行状态——（因等待其他资源，主动交出CPU）—–挂起状态

挂起状态———–（等待的非CPU资源到位了）———就绪状态

就绪|运行|挂起状态———————————————终止状态

PCB进程控制块

结构体struct task_struct 位于sched.h文件中

  • 进程id，pid_t类型，非负整数
  • 进程的状态，初始、就绪、运行、挂起、停止等状态
  • 进程切换时需要保存和恢复的一些CPU寄存器
  • 描述虚拟地址空间的信息
  • 描述控制终端的信息
  • 当前工作目录
  • umask掩码
  • 文件描述符表，包含很多指向file结构体的指针
  • 和信号相关的信息
  • 用户id和组id
  • 会话（Session）和进程组
  • 进程可以使用的资源上限 ulimit -a 查看所有资源的上限
环境变量

env查看所有环境变量

key=val =两边都不能有空格

1
2
3
4
#include<stdlib.h>
getenv("HOME");//返回一个字符串
setenv//设置环境变量
unsetenv//删除环境变量

2 掌握fork/getpid/getppid函数的使用

fork 创建一个新的进程

1
pid_t fork(void);

失败返回-1；

成功两次返回：父进程返回 子进程的id；子进程返回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
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(){
    printf("begin...\n");
    pid_t = fork();
    
    //进程创建失败
    if(pid < 0){
        perror("fork err");
        exit(1);
    }
    
    //进程创建成功
    if(pid == 0){
        //子进程
        printf("I am a child，pid=%d，ppid=%d\n",getpid(),getppid());
    }
    else if(pid>0){
        //父进程的逻辑
        printf("childepid=%d,self=%d,ppid=%d\n",pid,getpid(),getppid());
        sleep(1);//让父进程缓1s再死，避免孤儿进程
    }
    printf("End...\n");
    return 0;
}

创建n个子进程：

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>

int main(){
    int n=5;
    int i=0;
    pid_t pid = fork();
    for(i=0;i<5;i++){//父进程循环结束
    	pid = fork();
    	if(pid == 0){
    		//son
    		printf("I am son,pid=%d,ppid=%d\n",getpid(),getppid());
    		break;//子进程退出循环的接口
    	}else if(pid>0){
    		//father
    		printf("I am father,pid=%d,ppid=%d\n",getpid(),getppid());
    	}
    }
    
    //尽量精确控制父子进程的退出顺序
    sleep(i);
    if(i<5){
        //son
        printf("I am child,will exit,pid=%d,ppid=%d",getpid(),getppid());
    }else{
        //father
        printf("I am parent,will out pid=%d,ppid=%d\n",getpid(),getppid());
    }
       
    return 0;
}

父子进程共享

父子相同点：全局变量、.data、.text、栈、堆、环境变量、用户ID、宿主目录、进程工作目录、信号处理方式

父子不同点：进程ID、fork返回值、父进程ID、进程运行时间、闹钟（定时器）、未决信号集

父子进程之间遵循读时共享，写时复制原则。节省内存开销。

父子进程不共享全局变量

3 熟练掌握ps/kill命令使用

ps aux 查看进程信息

ps ajx 追溯进程之间的血缘关系 init（进程的祖先）—–sshd—–bash——其他子进程

kill -9 2890： -9是9号信号SIGKILL；2890是进程id

kill -l：可以查看所有信号共64个

ps aux|grep a.out可以查看当前的进程

ps aux|grep a.out|grep -v grep |wc -l返回数字，表示创建了几个子进程

4 熟练掌握execl/execlp函数的使用

1
2
3
4
5
//执行其他程序
int execl(const char*path,const char *arg,...);

//执行程序的时候，使用PATH环境变量，执行的程序可以不用加路径
int execlp(const char*file,const char *arg,...);

exec族函数：底层实现：代码段、数据段替换，进程ID啥的都不变，换核不换壳；

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<unistd>
#include<stdio.h>
int main(){

	//execlp("ls","ls","-l","--color=auto",NULL);
	execl("/bin/ls","ls","-l","--color=auto",NULL);

	//不需要判断返回值
	perror("exec err");
	printf("hello\n");
	
	return 0;
}

execl实现自定义程序

5 说出什么是孤儿进程 什么是僵尸进程

孤儿进程：父亲死了，子进程被init进程领养。

僵尸进程：子进程死了，父进程没有回收子进程的资源（PCB）。

orphan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<unistd.h>
int main(){
	pid_t pid = fork();
	if(pid == 0){
		while(1){
			printf("I am child,pid=%d,ppid=%d\n",getpid(),getppid());
			sleep(1);
		}
	}else if(pid>0){
		printf("I am parent,pid=%d,ppid=%d\n",getpid(),getppid());
		sleep(5);
		printf("I am parent,I will die!\n");
	}
	return 0;
}

此时，ctrl+c已经终止不了程序了，因为父进程已经死了，子进程脱离shell管制；此处应有kill -9 childpid

zombie

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<unistd.h>
int main(){
    pid_t pid = fork();
    if(pid==0){
        printf("I am child,pid=%d,ppid=%d\n",getpid(),getppid());
		sleep(5);
		printf("I am child,I will die!\n");
    }else if(pid>0){
        while(1){
            printf("I am parent,pid=%d",getpid());
            sleep(1);
        }
    }
    return 0;
}

回收僵尸进程：杀死僵尸进程的父亲，僵尸进程由init领养，负责回收，kill -9 parentpid。

僵尸进程是不能用kill直接清除的。

6 熟练掌握wait函数的使用

避免产生僵尸进程

1
2
//回收子进程，知道子进程的死亡原因
pid_t wait(int * status);//status是传出参数；成功返回终止的子进程id，失败返回-1

wait

作用：

  • 阻塞等待 等子进程死亡
  • 回收子进程资源
  • 查看死亡原因

子进程死亡原因：

  • 正常死亡WIFEXITED，为真，使用WEXITSTATUS得到退出状态；
  • 非正常死亡WIFSIGNALED，为真，使用WTERMSIG得到信号。
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
#include<stdio.h>
#inlcude<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
    pid_t pid = fork();
    if(pid==0){
        printf("I am child,will die!\n");
        sleep(2);
        //while(1){}//通过外部kill杀死，非正常死亡
        //return 101; //正常死亡
        //exit(102); //正常死亡
    }else if(pid>0){
        printf("I am parent,wait for child die!\n");
        
        int status;     
        pid_t wpit = wait(&status);      
        printf("wait ok,wpid=%d,pid=%d\n",wpid,pid);
        
        //正常死亡
        if(WIFEXITED(status)){
            printf("child exit with %d\n",WEXITSTATUS(status));
        }
        //非正常死亡
        if(WIFSIGNALED(status)){
            printf("child killed by %d\n",WTERMSIG(status));
        }
        
        while(1)
        {
            sleep(1);
        }   
    }
    return 0;
}

wait回收多个进程：

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
#include<stdio.h>
#inlcude<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
	int n=5;
	int i=0;

    pid_t pid; 
    for(i=0;i<5;i++){
    	pid = fork();
    	if(pid==0){
    		printf("I am child,pid=%d\n",getpid());
    		break;
    	}
    }
    sleep(1);
    if(i==5){
    	for(i=0;i<5;i++){
    		pid_t wpid=wait(NULL);//阻塞，直到回收
    		printf("wpid=%d\n",wpid);//能到这一步说明已经回收了
    	}
    	while(1){
            sleep(1);
        }   
    }
    return 0;
}

7 熟练掌握waitpid函数的使用

避免产生僵尸进程

waitpid

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//
pid_t waitpid(pid_t pid,int *status,int options);

pid:
<-1 组id
-1 回收任意
0 回收和调度进程组id相同组内的子进程
>0 回收指定的pid

options：
0与wait相同，也会阻塞
WNOHANG如果当前没有子进程退出的，会立刻返回

返回值：
如果设置了WNOHANG，那么如果没有子进程退出，返回0；
如果有子进程退出，返回退出的pid；如果失败返回-1（没有子进程）；

waitpid回收进程：

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
#include <stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
	pid_t pid = fork();
	if(pid==0){
		printf("I am child.pid=%d\n",getpid());
		sleep(2);
	}else if(pid>0){
		printf("I am parent,pid=%d\n",getpid());
		int ret;  
		
		while((ret = waitpid(-1,NULL,WNOHANG)) == 0){
            sleep(1);
        }
		printf("ret=%d\n",ret);
        
        ret = waitpid(-1,NULL,WNOHANG);
        if(ret<0){
            perror("wait err");
        }
        
		while(1){
			sleep(1);
		}
	}
	return 0;
}

waitpid回收多个进程：

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
#include<stdio.h>
#inlcude<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
	int n=5;
	int i=0;

    pid_t pid; 
    for(i=0;i<5;i++){
    	pid = fork();
    	if(pid==0){
    		
    		break;
    	}
    }
    sleep(1);
    if(i==5){
    	//parent 主要用于回收
        printf("I am parent!\n");
        //如何使用waitpid回收？  -1代表子进程都死了，都收了
        while(1){
            pid_t wpid=waitpid(-1,NULL,WNOHANG);//阻塞，直到回收
            if(wpid == -1){
                break;
            }else if(wpid>0){
                printf("wpid=%d\n",wpid);//能到这一步说明已经回收了
            }
        } 
        //保持父进程的活性，看有没有僵尸
        while(1){
            sleep(1);
        }
    	 
    }
    if(i<5){
        printf("I am child,i=%d,pid=%d\n",getpid());
    }
    return 0;
}

展开全文 >>

GitHub+Hexo搭建过程记录

1 搭建步骤：

1 node安装

官网地址：https://nodejs.org/en/download/
下载好直接安装，一直下一步，安装成功了以后打开cmd，输入node -v查看版本号，看到版本号，说明安装成功。

2 cnpm安装

由于我们被墙的厉害，所以使用npm下载模块时候会发现效率真的很慢，所以推荐淘宝的镜像，安装cnpm的cmd指令如下：

$ npm install -g cnpm --registry=https://registry.npm.taobao.org
安装完成后，输入cnpm -v ，不报错就是成功。

3 安装hexo：cnpm install -g hexo-cli （全局）

4 在对应目录下新建一个目录：mkdir blog

5 hexo init，创建，成功后出现的提示 👇

1
INFO  Start blogging with Hexo!

6 启动：先clean一下，再生成 g：generate 的意思

1
hexo cleanhexo g

7 运行：hexo s ，成功后👇

1
INFO  Start processingINFO  Hexo is running at http://localhost:4000 . Press Ctrl+C to stop.

8 打开localhost：4000，进入自动生成的第一篇博文：hello world

2 写博客

  1. hexo n “我的第一篇博客” ， n：new

    1
    INFO  Created: D:\github\blog\source\_posts\我的第一篇博客.md

  2. cd 到该目录下，有两篇文章，分别是hello world 和 刚创建的

  3. 我是通过typora对内容进行编辑的，很好用

  4. 编辑结束，保存文章

  5. 退回到blog文件夹下，先clean，在重新生成并启动

  6. 打开就能看到新建的博客啦~~

3 部署：免费方式GitHub

  1. 首先在自己的GitHub上创建一个仓库，命名为：用户名.github.io

  2. 回到命令行，安装一个插件：cnpm install hexo-deployer-git –save

    iOS的 ls 对应 win 的 dir 查看文件用

  3. 配置blog下的 _config.yml 文件，win用户可以使用notepad++来修改👇，注意，每个后面都有空格！！

    1
    deploy:  type: git  repo: https://github.com/GAOGAO1994/GAOGAO1994.github.io.git  branch: master

  4. 部署到远端：hexo d，d 就是 deploy ， 部署上去的意思。

    1
    Branch 'master' set up to track remote branch 'master' from 'https://github.com/GAOGAO1994/GAOGAO1994.github.io.git'.INFO  Deploy done: git

    👆部署成功

  5. 现在我们直接通过 ：https://username.github.io/ 就可以访问我们的博客~~

4 更换主题

  1. 定位到blog文件夹下：git clone https://github.com/litten/hexo-theme-yilia themes/yilia

  2. 修改 _config.yml 文件

    1
    theme: yilia

  3. 重新 clean 、g、d

  4. 成功

    PS：此主题需根据提示下载相关插件以及做相应配置

    • blog下：cnpm i hexo-generator-json-content –save

    • 在配置文件中加入

      1
      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

配置文件中相应字段修改后就可以实现个性化主题了 ~

https://hexo.io/zh-cn/docs/configuration.html

展开全文 >>