Linux应用层

这里我将学习的进程与线程分为三个大部分

1.进程创建：使用fork创建子进程，execve执行新程序。
2.​进程通信：匿名管道、有名管道、共享内存、消息队列、信号
​3.线程管理：线程创建、终止、同步（互斥锁、读写锁、条件变量等）
要想进一步了解系统的底层原理可以去看操作系统相关的知识，了解了解进程线程的内存模型，以及进程线程在系统上的工作原理。这里有一篇不错的文章
https://zybtree.github.io/2020/08/10/进程-线程模型/

进程创建

使用 fork 创建子进程

• fork 的作用：fork 是 Linux 系统中用于创建子进程的系统调用。调用 fork 后，父进程会复制一份自己的地址空间给子进程，子进程从 fork 返回处开始执行。这里涉及到写时复制
• 返回值：
• -1：创建失败。
• 0：在子进程中返回。
• > 0：在父进程中返回子进程的 PID。
• 代码示例：

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

int main(int argc, char *argv[]){
    //调用fork之前 代码都在父进程中运行
    printf("当前%d\n", getpid());

    /**不需要传参
     * return: int 进程号
     *        (1):-1 出错
     *        (2): 父进程中表示子进程的PID
     *        (3): 子进程中显示为0
     * __pid_t fork (void)
     */
    //使用fork创建子进程 fork之后所有的代码都是在父子进程中各自执行一遍
    pid_t pid = fork();
    
    //printf("%d\n", pid);
    if(pid < 0){
        printf("子进程创建失败!");
        return 1;
    }else if(pid == 0){
        //当前为子进程
        printf("子进程 %d 创建成功! 父进程是 %d\n", getpid(), getppid());
    }else{
        //当前为父进程
        printf("当前为父进程 %d 子进程是 %d\n", getpid(), pid);
    }
    return 0;
}

使用 execve 执行新程序

• execve 的作用：execve 用于替换当前进程的地址空间为新的程序，并执行该程序。调用成功后，原程序的代码和数据被新程序替换。这也意味着该进程的pid保持不变
• 代码示例：

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>

int main(int argc, char *argv[]){
    //跳转之前
    char *name = "banzhang";
    printf("我是%s 编号%d\n", name, getpid());

    //执行跳转
    /**
     * const char *__path: 执行程序的路径
     * char *const __argv[]：传入参数 -> 对应执行程序main方法的第二个参数
     *      (1): 第一个参数固定是程序的名称 -> 执行的程序路径
     *      (2): 执行程序要传入的参数
     *      (3): 结尾的最后一个参数一定是NULL
     * char *const __envp[]: 传递的环境变量
     *      (1): 环境变量参数: key=value
     *      (2): 最后一个参数为NULL
     * return: 成功根本没法返回 下面的代码也没有意义 失败返回-1;
     * int execve (const char *__path, char *const __argv[], char *const __envp[])
     */
    char *args[] = {"/home/stream/process_test/erlou", name, NULL};
    char *envs[] = {"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/snap/bin",NULL};
    int re = execve(args[0], args, envs);
    if(re == -1){
        printf("调用程序失败!\n");
        return 1;
    }

    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include<sys/types.h>
#include<sys/wait.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

int main(int argc, char *argv[]){
    pid_t cpid;
    int pipefd[2];

    //将程序传近来的第一个命令行参数 通过管道传输给子进程
    if(argc != 2){
        fprintf(stderr, "%s:请填写需要传递的信息!\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    //创建管道
    if(pipe(pipefd) == -1){
        perror("创建管道失败");
        exit(EXIT_FAILURE);
    }

    //复制父子进程
    cpid = fork();
    if(cpid == -1){
        perror("邀请新学员失败");
        exit(EXIT_FAILURE);
    }
    if(cpid == 0){
        //子进程 读取管道的数据 打印到控制台
        //write(pipefd[1], argv[1], strlen(argv[1]));
        close(pipefd[1]);
        char str[100] = {0};
        sprintf(str, "新学员 %d接受信息\n", getpid());
        write(STDOUT_FILENO, &str, sizeof(str));
        char buf;
        while(read(pipefd[0], &buf, 1) > 0){
            write(STDOUT_FILENO, &buf, 1);
        }
        write(STDOUT_FILENO, "\n", 1);
        close(pipefd[0]);
        _exit(EXIT_SUCCESS);
    }else{
        //父进程 写入管道数据 打印到控制台
        //close(pipefd[0]);
        // 将数据写入
        printf("老学员%d对新学员传递信息\n", getpid());
        write(pipefd[1], argv[1], strlen(argv[1]));
        close(pipefd[1]);
        waitpid(cpid, NULL, 0);
        // char buf;
        // while(read(pipefd[0], &buf, 1) > 0){
        //     write(STDOUT_FILENO, &buf, 1);
        // }
        // write(STDOUT_FILENO, "\n", 1);
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    }
    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
33
34
35
36
37
38
39
40
#include<sys/stat.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include<errno.h>

int main(int argc, char *argv[]){
    int fd;
    char *pipe_path = "/tmp/myfifo";
    if(mkfifo(pipe_path, 0664) != 0){
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }
    //对有名管道的特殊文件 创建fd
    fd = open(pipe_path, O_WRONLY);
    if(fd == -1){
        perror("open");
        exit(EXIT_FAILURE);
    }
    char buf[100];
    size_t read_num;
    while((read_num = read(STDIN_FILENO, buf, 100)) > 0){
        write(fd, buf, read_num);
    }
    if(read_num < 0){
        perror("read");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("发送数据到管道完成 进程终止");
    close(fd);
    if(unlink(pipe_path) == -1){
        perror("unlink");
    }

    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
33
34
35
#include<sys/stat.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include<errno.h>

int main(int argc, char *argv[]){
    int fd;
    char *pipe_path = "/tmp/myfifo";

    //对有名管道的特殊文件 创建fd
    fd = open(pipe_path, O_RDONLY);
    if(fd == -1){
        perror("open");
        exit(EXIT_FAILURE);
    }
    char buf[100];
    size_t read_num;
    while((read_num = read(fd, buf, 100)) > 0){
        write(STDOUT_FILENO, buf, read_num);
    }

    if(read_num < 0){
        perror("read");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("接受管道数据完成 进程终止");
    close(fd);

    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<sys/wait.h>
#include<string.h>

int main(int argc, char const *argv[])
{
    char *share;
    // 创建一个共享内存对象
    char shm_name[100]  ={0};
    sprintf(shm_name, "/letter%d", getpid());
    int fd;
    fd = shm_open(shm_name, O_RDWR | O_CREAT, 0664);
    if(fd < 0){
        perror("shm_open");
        exit(EXIT_FAILURE);
    }

    // 设置共享内存大小
    ftruncate(fd, 1024);

    // 内存映射
    share = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(share == MAP_FAILED){
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    // 映射完成之后关闭fd连接 不是释放
    close(fd);

    // 使用内存映射实现进程间的通讯
    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if(pid == 0){
        strcpy(share, "你是个好人\n");
        printf("新学员%d完成回信\n", getpid());
    }else{
        waitpid(pid, NULL, 0);
        printf("老学员%d收到了新学员%d的回信:%s", getpid(), pid, share);

        // 释放映射区
        int re = munmap(share, 1024);
        if(re == -1){
            perror("munmap");
            exit(EXIT_FAILURE);
        }
        // 释放共享内存对象
        shm_unlink(shm_name);
    }

    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include<mqueue.h>
#include<stdio.h>
#include<time.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>

int main(int argc, char const *argv[])
{
    //创建消息队列
    struct mq_attr attr;

    //有用的参数 表示消息队列的容量
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = 100;

    // 用mq_open时被忽略的参数
    attr.mq_flags = 0;
    attr.mq_curmsgs = 0;
    
    char *mq_name = "/p_c_mq";
    mqd_t mqdes = mq_open(mq_name, O_RDWR | O_CREAT, 0664, &attr);
    if(mqdes == (mqd_t)-1){
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    //不断接收控制台中的数据 发送到消息队列
    char read_buf[100];
    struct timespec time_info;

    while(1){
        memset(read_buf, 0, 100);

        clock_gettime(0, &time_info);
        time_info.tv_sec += 15;
        // 读取消息队列的数据
        if (mq_timedreceive(mqdes, read_buf, 100, NULL, &time_info) == -1)
        {
            perror("mq_tiemreceive");
        }

        //判断当前数据是否为结束信息
        if(read_buf[0] == EOF){
            printf("接收到生产者发送的结束信息 准备退出...\n");
            break;
        }


        //正常的读取的消息队列信息打印到控制台

        printf("接收到来自生产者发送的的消息：%s\n", read_buf);
    }

    //关闭消息队列描述符
    close(mqdes);

    //清除消息队列
    mq_unlink(mq_name);

    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include<mqueue.h>
#include<stdio.h>
#include<time.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>

int main(int argc, char const *argv[])
{
    //创建消息队列
    struct mq_attr attr;

    //有用的参数 表示消息队列的容量
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = 100;

    // 用mq_open时被忽略的参数
    attr.mq_flags = 0;
    attr.mq_curmsgs = 0;
    
    char *mq_name = "/p_c_mq";
    mqd_t mqdes = mq_open(mq_name, O_RDWR | O_CREAT, 0664, &attr);
    if(mqdes == (mqd_t)-1){
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    //不断接收控制台中的数据 发送到消息队列
    char write_buf[100];
    struct timespec time_info;

    while(1){
        memset(write_buf, 0, 100);
        ssize_t read_count = read(0, write_buf, 100);
        clock_gettime(0, &time_info);
        time_info.tv_sec += 5;
        if(read_count == -1){
            perror("read");
            continue;
        }else if(read_count == 0){
            // 就是在控制台中输入 ctrl + d的时候
            printf("EOF, exit..\n");
            char eof = EOF;
            if (mq_timedsend(mqdes, &eof, 1, 0, &time_info) == -1)
            {
                perror("mq-timesend");
            }
            break;
        }

        //正常接收控制台数据并发送
        if (mq_timedsend(mqdes, write_buf, strlen(write_buf), 0, &time_info) == -1)
        {
            perror("mq-timesend");
        }
        printf("从命令行接收的数据已经发送给消息队列\n");
    }

    //关闭消息队列描述符
    close(mqdes);

    return 0;
}

信号量

信号量机制由信号量 和P, V操作两部分组成, 信号量是一个特殊的变量, 是进程传递的一个整数数值，只能被两个标准原语所访问，及p(wait操作)操作, v(signal操作)操作。P是阻塞原语，V是唤醒原语。P对信号量值-1后, 小于0则执行阻塞操作。反之V +1后， 大于等于零时不执行唤醒操作，小于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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include<pthread.h>
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<semaphore.h>
#include<sys/mman.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(int argc, char const *argv[])
{
    char *shm_name = "unnamed_sem_shm";
    //创建共享内存
    int fd = shm_open(shm_name, O_CREAT | O_RDWR, 0666);
    //调整共享内存大小
    ftruncate(fd, sizeof(sem_t));
    //完成映射
    sem_t *sem = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    //初始化信号量
    sem_init(sem,1, 0);
    //创建父子进程
    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
    }else if(pid == 0){
        sleep(1);
        printf("这是子进程\n");
        sem_post(sem);
    }else{
        sem_wait(sem);
        printf("这是父进程\n");
        waitpid(pid, NULL, 0);
    }

    //回收资源
    if(pid > 0){
        if(sem_destroy(sem) == -1){
            perror("sem_destroy");
        }

    }
    if(munmap(sem, sizeof(sem_t)) == -1){
        perror("munmap");
    }
    if(close(fd) == -1){
        perror("close");
    }
    if(pid > 0){
        if(shm_unlink(shm_name) == -1){
            perror("shm_unlink");
        }
    }
    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<semaphore.h>
#include<sys/mman.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(int argc, char const *argv[])
{
    //char *shm_value_name = "/named_sem_shm_value";
    char *sem_name = "/named_sem_shm";

    //创建共享内存对象
    // int value_fd = shm_open(sem_name, O_CREAT | O_RDWR, 0666);

    //初始化有名信号量
    sem_t * sem = sem_open(sem_name, O_CREAT, 0666, 0);

    //创建父子进程
    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
    }else if(pid == 0){
        sleep(1);
        printf("这是子进程\n");
        sem_post(sem);
    }else{
        sem_wait(sem);
        printf("这是父进程\n");
        waitpid(pid, NULL, 0);
    }

    //回收资源

    if(sem_close(sem) == -1){
        perror("close");
    }
    if(pid > 0){
        if(sem_unlink(sem_name) == -1){
            perror("shm_unlink");
        }
    }
    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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<semaphore.h>
#include<time.h>
#include<pthread.h>

sem_t *full;
sem_t *empty;

int shard_num;

int rand_num(){
    srand(time(NULL));
    return rand();
}

void *producer(void *arg){
    for (size_t i = 0; i < 5; i++)
    {
        // 获取信号量
        sem_wait(empty);
        printf("\n第%d轮数据传输\n", i + 1);
        sleep(1);
        shard_num = rand_num();

        //释放信号量
        sem_post(full);
    }
    
}

void *consumer(void *arg){
    for (size_t i = 0; i < 5; i++)
    {
        // 获取信号量
        sem_wait(full);
        printf("\n第%ld轮消费者开始读取数据\n", i + 1);
        sleep(1);
        printf("接收到的数据是%d", shard_num);

        //释放信号量
        sem_post(empty);
    }
    
}

void *consumer(void *arg){

}

int main(int argc, char const *argv[])
{
    full = (sem_t *)malloc(sizeof(sem_t));
    empty = (sem_t *)malloc(sizeof(sem_t));
    // 初始化信号量
    sem_init(empty, 0, 1);
    sem_init(full, 0, 0);

    // 创建生产者和消费者线程
    pthread_t producer_id, consumer_id;
    pthread_create(&producer_id, NULL, producer, NULL);
    pthread_create(&consumer_id, NULL, consumer, NULL);

    //等待线程全部完成
    pthread_join(producer_id, NULL);
    pthread_join(consumer_id, NULL);

    //代码最后摧毁信号量
    sem_destroy(full);
    sem_destroy(empty);
    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
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<unistd.h>

void sigint_handle(int signum){
    printf("\n受到%d信号 停止程序\n", signum);
    exit(signum);
}

int main(int argc, char const *argv[])
{
    if (signal(SIGINT, sigint_handle) == SIG_ERR)
    {
        perror("signal");
        return 1;
    }
    
    while(1){
        sleep(1);
        printf("你好, 在吗\n");
    }
    return 0;
}

说些什么吧！

valine