vs c 创建进程

在 C 语言中，可以使用 `fork()` 函数来创建子进程。该函数会返回两次，一次在父进程中返回子进程的进程ID，另一次在子进程中返回0。下面是一个简单的示例代码：

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

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        printf("Child process!\n");
    } else if (pid > 0) {
        // 父进程
        printf("Parent process! Child process PID: %d\n", pid);
    } else {
        // 创建进程失败
        printf("Failed to create child process!");
    }
    return 0;
}

在上面的代码中，调用 `fork()` 函数会创建一个子进程，子进程会输出 "Child process!"，父进程会输出 "Parent process! Child process PID: XX"，其中 XX 是子进程的进程ID。注意，虽然父子进程会同时执行，但它们是完全独立的进程，具有各自的内存空间和 CPU 时间。

相关问题

linux c语言创建进程池

要在Linux下使用C语言创建进程池，可以按照以下步骤：

1. 创建进程池结构体，用于存储进程池相关信息，如进程池大小、当前已有进程数、互斥锁等。

2. 在主进程中创建进程池，即创建一定数量的子进程，将它们放入进程池中。

3. 当有任务需要处理时，主进程从进程池中取出一个空闲进程，将任务分配给它处理。

4. 子进程在处理完任务后，将自己标记为空闲状态，然后等待下一次任务分配。

以下是一个简单的进程池实现示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <pthread.h>

#define MAX_PROCESS_NUM 10
#define MAX_TASK_NUM 100

typedef struct {
    pid_t pid;
    int is_busy;
} Process;

typedef struct {
    pthread_mutex_t lock;
    Process *process_list;
    int process_num;
    int task_num;
} ProcessPool;

int create_process_pool(int num, ProcessPool *pool);
int destroy_process_pool(ProcessPool *pool);
int process_task(ProcessPool *pool);

int main() {
    ProcessPool pool;
    if (create_process_pool(MAX_PROCESS_NUM, &pool) == -1) {
        printf("Failed to create process pool.\n");
        exit(1);
    }

    // 处理任务
    for (int i = 0; i < MAX_TASK_NUM; i++) {
        process_task(&pool);
    }

    if (destroy_process_pool(&pool) == -1) {
        printf("Failed to destroy process pool.\n");
        exit(1);
    }
    return 0;
}

int create_process_pool(int num, ProcessPool *pool) {
    pool->process_num = num;
    pool->process_list = malloc(num * sizeof(Process));
    if (pool->process_list == NULL) {
        return -1;
    }

    // 初始化互斥锁
    pthread_mutex_init(&pool->lock, NULL);

    // 创建子进程
    for (int i = 0; i < num; i++) {
        pid_t pid = fork();
        if (pid == -1) {
            return -1;
        } else if (pid == 0) {
            // 子进程
            while (1) {
                // 等待任务
                pthread_mutex_lock(&pool->lock);
                for (int j = 0; j < pool->process_num; j++) {
                    if (pool->process_list[j].pid == getpid()) {
                        pool->process_list[j].is_busy = 0;
                        break;
                    }
                }
                pool->task_num--;
                pthread_mutex_unlock(&pool->lock);

                // 处理任务
                printf("Process %d is processing task %d.\n", getpid(), MAX_TASK_NUM - pool->task_num);
                sleep(1);

                // 标记为空闲状态
                pthread_mutex_lock(&pool->lock);
                for (int j = 0; j < pool->process_num; j++) {
                    if (pool->process_list[j].pid == getpid()) {
                        pool->process_list[j].is_busy = 0;
                        break;
                    }
                }
                pthread_mutex_unlock(&pool->lock);
            }
        } else {
            // 父进程
            pool->process_list[i].pid = pid;
            pool->process_list[i].is_busy = 0;
        }
    }

    // 初始化任务数
    pool->task_num = MAX_TASK_NUM;
    return 0;
}

int destroy_process_pool(ProcessPool *pool) {
    // 等待子进程退出
    for (int i = 0; i < pool->process_num; i++) {
        waitpid(pool->process_list[i].pid, NULL, 0);
    }

    // 释放资源
    free(pool->process_list);
    pthread_mutex_destroy(&pool->lock);
    return 0;
}

int process_task(ProcessPool *pool) {
    // 找出空闲进程
    int index = -1;
    pthread_mutex_lock(&pool->lock);
    for (int i = 0; i < pool->process_num; i++) {
        if (!pool->process_list[i].is_busy) {
            pool->process_list[i].is_busy = 1;
            index = i;
            break;
        }
    }
    pthread_mutex_unlock(&pool->lock);

    if (index == -1) {
        // 进程池已满，等待空闲进程
        sleep(1);
        process_task(pool);
    } else {
        // 分配任务
        printf("Task %d is assigned to process %d.\n", MAX_TASK_NUM - pool->task_num, pool->process_list[index].pid);
        pool->task_num--;
    }
    return 0;
}

C语言创建多个进程

在 C 语言中，可以使用 `fork()` 函数来创建子进程。`fork()` 函数会创建一个新的进程，该进程是调用进程的副本，新进程从调用进程的位置开始执行。下面是一个简单的示例代码，可以创建两个子进程并分别输出它们的进程 ID：

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

void worker() {
    printf("Child process ID: %d\n", getpid());
}

int main() {
    pid_t pid1, pid2;
    // 创建第一个子进程
    pid1 = fork();
    if (pid1 == 0) {
        // 子进程1
        worker();
        return 0;
    } else {
        // 创建第二个子进程
        pid2 = fork();
        if (pid2 == 0) {
            // 子进程2
            worker();
            return 0;
        } else {
            // 等待两个子进程结束
            waitpid(pid1, NULL, 0);
            waitpid(pid2, NULL, 0);
            return 0;
        }
    }
}

在上面的代码中，`worker` 函数是子进程要执行的任务，`getpid()` 可以获取当前进程的进程 ID。使用 `fork()` 函数创建子进程，并分别判断父进程和子进程的执行路径。执行上述代码，可以看到两个子进程的进程 ID 分别输出。