C语言进程（第二章，wait，sleep，waitpid，pthread_mutex_lock，pthread_mutex_unlock）

#include <sys/wait.h>
pid_t wait(int *status);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    pid_t pid;      //定义一个进程id，用于保存 fork （）函数的返回值
    int status;     //定义一个整型变量，接收子进程退出状态
    pid = fork();   //调用 fork 函数来创建子进程，并将返回值赋值给pid
    if (pid == -1) {  //当pid=-1时，说明fork函数没有成功创建新进程，出现异常错误退出程序
        printf("error: 创建进程失败 \n");
        exit(1);
    } else if (pid == 0) {   //当pid=0时，说明现在执行的是子进程。输出信息，等待1秒后终止。
        printf("我是子进程，我的pid是 %d\n", getpid());
        sleep(1);
        exit(2);
    } else {   //当pid>0时，说明现在执行的是父进程。输出信息，并使用wait系统调用等待子进程结束，并获取子进程退出状态码。
        printf("我是父进程，我的pid是 %d\n", getpid());
        wait(&status);
        printf("已终止的子进程id是 %ld 返回状态：%d \n", (long) pid, WEXITSTATUS(status));
        exit(0);  //父进程结束
    }
    return 0;
}

if (pid == -1) {
    printf("error: 创建进程失败 \n");
    exit(1);
} else if (pid == 0) {
    printf("我是子进程，我的PID是 %d\n", getpid());
    sleep(1);
    exit(2);
}

else {
    printf("我是父进程，我的PID是 %d\n", getpid());   //4号调试信息
    wait(&status);
    printf("已终止的子进程ID是 %ld 返回状态：%d \n", (long) pid, WEXITSTATUS(status));   //6号调试信息
    exit(0);
}

#include <unistd.h>
unsigned int sleep(unsigned int seconds);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
   printf("正在进行休眠...\n");
   sleep(5);
   printf("休眠结束\n");
   return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    pid_t pidA, pidB;
    pidA = fork();
    if (pidA == -1) {  //当pidA=-1时 说明创建进程失败，输出错误信息。 
        printf("error: 创建进程A失败 \n");
        return 1;
    } else if (pidA == 0) {  //当pidA=0时，说明现在执行的是子进程 A。
        printf("我是子进程A，我的PID是 %d.\n", getpid());
        sleep(1);
        printf("子进程A退出.\n");
        return 0;
    }
    pidB = fork();
    if (pidB == -1) {   //当pidB=-1时,说明创建进程B失败，输出错误信息并回收进程A的资源后退出
        printf("error: 创建进程B失败 \n");
        wait(&pidA);    // 回收A的资源
        return 1;
    } else if (pidB == 0) {   //当pidB=0时，说明现在执行的是子进程B。
        printf("我是子进程B，我的PID是 %d.\n", getpid());
        sleep(2);
        printf("子进程B退出.\n");
        return 0;
    }
    // 父进程等待两个子进程都结束
    waitpid(pidA, NULL, 0);
    waitpid(pidB, NULL, 0);
    printf("b输出完毕\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/time.h>
int main() {
    int i, status;
    // 创建5个子进程
    for(i = 0; i < 5; i++) {  
        pid_t pid = fork();
        if(pid == 0) { // 子进程处理逻辑
            struct timeval start, end;
            gettimeofday(&start, NULL); // 记录开始时间
            sleep(i+1); // 模拟子进程执行耗时
            gettimeofday(&end, NULL); // 记录结束时间
            long runtime = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_usec - start.tv_usec) / 1000; // 计算执行时间（毫秒）
            printf("Child %d finished in %ldms\n", i+1, runtime);
            exit(i+1); // 结束子进程并返回子进程编号
        }
    }
    // 等待每个子进程执行并输出结果
    for(i = 0; i < 5; i++) {
        pid_t pid = waitpid(-1, &status, 0); // 父进程暂停等待任意子进程完成
        if(WIFEXITED(status)) { // 检查进程是否正常终止
            int child_id = WEXITSTATUS(status); // 获取子进程的退出状态（也就是返回值，即子进程编号）
            printf("Parent: Child %d finished.\n", child_id);
        } else { // 检查进程是否异常终止
            if (pid > 0) {
                perror("Child terminated with an error status");
            } else if (pid == -1) {
                perror("Error while waiting for the child process to terminate");
            }
        }
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define SIZE 10
int count = 0;
int buffer[SIZE]; 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* producer(void* arg) {
    int val = *(int*) arg;
    while (1) {
        pthread_mutex_lock(&mutex);   // 获取互斥锁
        if (count < SIZE) {
            buffer[count++] = val;    // 向缓存中添加值
            printf("Producer produces value: %d\n", val);
        }
        pthread_mutex_unlock(&mutex);  // 释放互斥锁
    }
}
void* consumer(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex);   // 获取互斥锁
        if (count > 0) {
            int val = buffer[--count];
            printf("Consumer consumes value: %d\n", val);
        }
        pthread_mutex_unlock(&mutex);  // 释放互斥锁
    }
}
int main() {
    pthread_t producer_thread, consumer_thread;
    int prod_val = 5;
    pthread_create(&producer_thread, NULL, producer, &prod_val);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    return 0;
}

Producer produces value: 5
Consumer consumes value: 5
Producer produces value: 5
Consumer consumes value: 5
Producer produces value: 5
Consumer consumes value: 5
Producer produces value: 5
Consumer consumes value: 5
...