C++中fork()函数

#include <iostream>
#include <unistd.h>   // fork() 头文件
#include <sys/wait.h> // wait() 头文件
#include <cstdlib>    // exit() 头文件
int main() {
    // 调用fork创建子进程
    pid_t pid = fork();
    // 错误处理：fork失败
    if (pid == -1) {
        std::cerr << "fork failed!" << std::endl;
        exit(exit_failure);
    }
    // 子进程分支（pid == 0）
    else if (pid == 0) {
        std::cout << "子进程：pid = " << getpid() 
                  << "，父进程pid = " << getppid() << std::endl;
        // 子进程执行完退出，避免继续执行后续代码
        exit(exit_success);
    }
    // 父进程分支（pid > 0）
    else {
        std::cout << "父进程：pid = " << getpid() 
                  << "，创建的子进程pid = " << pid << std::endl;
        // 父进程等待子进程结束，避免子进程变成“僵尸进程”
        wait(null); 
        std::cout << "子进程已退出" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main() {
    const int child_num = 3; // 创建3个子进程
    for (int i = 0; i < child_num; ++i) {
        pid_t pid = fork();
        if (pid == -1) {
            std::cerr << "fork failed!" << std::endl;
            exit(exit_failure);
        } else if (pid == 0) {
            // 子进程：打印自身编号和pid
            std::cout << "子进程" << i+1 << "：pid = " << getpid() << std::endl;
            exit(exit_success); // 关键：子进程退出，避免继续循环创建孙进程
        }
    }
    // 父进程：等待所有子进程退出
    for (int i = 0; i < child_num; ++i) {
        wait(null);
    }
    std::cout << "所有子进程已退出" << std::endl;
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <sys/wait.h>
int main() {
    int fd[2];
    // 创建匿名管道
    if (pipe(fd) == -1) {
        perror("pipe failed");
        return 1;
    }
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return 1;
    }
    if (pid == 0) { // 子进程：读数据
        close(fd[1]); // 关闭写端
        char buf[100];
        ssize_t bytes_read = read(fd[0], buf, sizeof(buf)-1);
        if (bytes_read > 0) {
            buf[bytes_read] = '\0';
            std::cout << "子进程读取到：" << buf << std::endl;
        }
        close(fd[0]); // 读完关闭读端
        return 0;
    } else { // 父进程：写数据
        close(fd[0]); // 关闭读端
        const char* msg = "hello from parent process!";
        write(fd[1], msg, strlen(msg));
        close(fd[1]); // 写完关闭写端
        wait(null); // 等待子进程
        std::cout << "父进程完成通信" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <cstring>

#define shm_key 1234 // 共享内存键值（唯一标识）
#define shm_size 1024 // 共享内存大小

int main() {
    // 创建共享内存段
    int shmid = shmget(shm_key, shm_size, ipc_creat | 0666);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }

    // 将共享内存映射到进程地址空间
    char* shm_addr = (char*)shmat(shmid, null, 0);
    if (shm_addr == (char*)-1) {
        perror("shmat failed");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return 1;
    }

    if (pid == 0) { // 子进程：读取共享内存
        std::cout << "子进程读取共享内存：" << shm_addr << std::endl;
        // 解除映射
        shmdt(shm_addr);
        return 0;
    } else { // 父进程：写入共享内存
        strcpy(shm_addr, "hello from parent via shared memory!");
        wait(null);
        // 解除映射并删除共享内存
        shmdt(shm_addr);
        shmctl(shmid, ipc_rmid, null);
        std::cout << "父进程释放共享内存" << std::endl;
    }

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>

// 共享变量（线程间通信的载体）
int shared_data = 0;
// 互斥锁：保护共享变量，避免数据竞争
std::mutex mtx;

// 线程1：修改共享变量
void write_data() {
    for (int i = 0; i < 5; ++i) {
        // 加锁：保证临界区（修改共享变量）原子执行
        std::lock_guard<std::mutex> lock(mtx);
        shared_data++;
        std::cout << "写线程：shared_data = " << shared_data << std::endl;
    }
}

// 线程2：读取共享变量
void read_data() {
    for (int i = 0; i < 5; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "读线程：shared_data = " << shared_data << std::endl;
    }
}

int main() {
    std::thread t1(write_data);
    std::thread t2(read_data);

    t1.join();
    t2.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::queue<int> msg_queue; // 共享队列（通信载体）
std::mutex mtx;
std::condition_variable cv; // 条件变量

// 生产者线程：写入数据
void producer() {
    for (int i = 1; i <= 3; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        msg_queue.push(i);
        std::cout << "生产者：写入数据 " << i << std::endl;
        cv.notify_one(); // 唤醒等待的消费者
    }
}

// 消费者线程：读取数据
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待条件：队列非空（避免虚假唤醒，用while而非if）
        cv.wait(lock, []() { return !msg_queue.empty(); });
        
        int data = msg_queue.front();
        msg_queue.pop();
        std::cout << "消费者：读取数据 " << data << std::endl;
        lock.unlock();
        
        if (data == 3) break; // 结束条件
    }
}

int main() {
    std::thread t_prod(producer);
    std::thread t_cons(consumer);

    t_prod.join();
    t_cons.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore<1> sem(0); // 初始值0：无数据
int shared_data = 0;

void producer() {
    shared_data = 100;
    std::cout << "生产者：设置shared_data = " << shared_data << std::endl;
    sem.release(); // 信号量+1，通知消费者
}

void consumer() {
    sem.acquire(); // 信号量-1，无数据则阻塞
    std::cout << "消费者：读取shared_data = " << shared_data << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();
    return 0;
}