#include <iostream>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

int cnt = 1;

void handler(int signo) {
    cout << "我是进程, 我捕捉到一个信号: " << signo << ", 这是第 " << cnt << " 次" << endl;
    cnt++;
}

int main() {
    signal(2, handler);
    sleep(1);
    cout << "进程已经设置完了" << endl;

    while (true)
    {
        cout << "我是一个正在运行中的进程: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cerrno>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::cerr;
using std::endl;
using std::string;

void usage(const string& proc) {
    cout << "Usage:\n\t" << proc << " sig pid" << endl;
}

// 模拟实现 kill命令
// ./mykill sig pid
int main(int argc, char* argv[]) {
    if (argc != 3) {
        usage(argv[0]);             // argv[0] 即为命令行的第一个字符串
        exit(1);
    }

    if (kill( (pid_t)atoi(argv[2]), atoi(argv[1]) ) == -1) {
        cerr << "kill error, " << strerror(errno) << endl;
        exit(2); 
    }
    
    return 0;
    
}

#include <iostream>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

int cnt = 1;

void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << ", 这是第 " << cnt << " 次" << endl;
    cnt++;
}

int main(int argc, char* argv[]) {
    signal(2, handler);

    while (true) {      // 循环给自己发送 信号2
        raise(2);
        sleep(1);
    }
    
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

int cnt = 1;

void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << ", 这是第 " << cnt << " 次" << endl;
    cnt++;
}

int main(int argc, char* argv[]) {
    signal(2, handler);

    while (true) {      // 循环给自己发送 信号2
        raise(2);
        sleep(1);
        if (cnt > 5)
            abort();
    }
    
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

int cnt = 1;

void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << ", 这是第 " << cnt << " 次" << endl;
    cnt++;
}

int main(int argc, char* argv[]) {
    signal(2, handler);
    signal(SIGABRT, handler);	// 捕捉 SIGABRT 信号

    while (true) {      // 循环给自己发送 信号2
        raise(2);
        sleep(1);
        if (cnt > 5)
            abort();
    }
    
    return 0;
}

#include <iostream>
#include <cerrno>
#include <unistd.h>
using std::cout;
using std::endl;

int cnt = 0;

int main(int argc, char* argv[]) {
    alarm(1);           // 设置 1s 的闹钟

    while (true) {
        cout << "count: " << cnt++ << endl;
    }

    return 0;
}

#include <iostream>

int main() {
    // 越界访问
    int arr[10];
    arr[100000] = 0;
    
    // 解引用空指针
    //int* pi = nullptr;
    //*pi = 10;
    
    // 除0
    //int i = 10;
    //i /= 0;

    return 0;
}

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << endl;
    exit(1);
}

int main() {
    // 捕捉进程, 自定义处理
    for(int sig = 1; sig <= 31; sig++) {
        signal(sig, handler);
    }
    // 越界访问
    int arr[10];
    arr[100000] = 0;
    
    // 解引用空指针
    //int* pi = nullptr;
    //*pi = 10;

    // 除0	
    //int i = 10;
    //i /= 0;

    return 0;
}

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

int cnt = 0;

void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << ", count: " << cnt++ << endl;
}

int main() {
    // 捕捉进程, 自定义处理
    signal(8, handler);
    
    // 除0	
    int i = 10;
    i /= 0;

    return 0;
}

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

int main() {
    pid_t id = fork();
    if(id == 0) {
        // 子进程 除0错误, 应该接收到 8信号
        int i = 10;
        i /= 0;
        exit(1);
    }

    // 父进程等待子进程
    int status = 0;
    waitpid(id, &status, 0);
    printf("exitcode: %d, signo: %d, core dump flag: %d\n", (status>>8) & 0xFF, status & 0x7F, (status>>7)&0x1);

    return 0;
}

int sigpending(sigset_t *set);
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::cerr;
using std::endl;

int cnt = 0;
void handler(int signo) {
    cout << "我是进程, pid: " << getpid() << ", 我捕捉到一个信号: " << signo << ", count: " << cnt++ << endl;
}

// 打印信号集的函数
void showSignals(sigset_t *signals) {
    // 使用 sigismember() 接口判断 31个普通信号是否在信号集中存在
    // 存在的信号输出1, 否则输出0
    for(int sig = 1; sig <= 31; sig++) {
        if(sigismember(signals, sig)) {
            cout << "1";
        }
        else {
            cout << "0";
        }
    }
    cout << endl;
}

int main() {
    // 先输出进程的 pid
    cout << "pid: " << getpid() << endl;

    // 定义sigsetmask()需要使用的 set 和 oldset, 并初始化
    sigset_t sigset, osigset;
    sigemptyset(&sigset);
    sigemptyset(&osigset);

    // 将进程的 所有普通信号屏蔽
    for(int sig = 1; sig <= 31; sig++) {
        sigaddset(&sigset, sig);
        signal(sig, handler);
    }
    sigprocmask(SIG_BLOCK, &sigset, &osigset);

    // 获取并打印进程的未决信号集
    sigset_t pendings;
    while(true) {
        sigemptyset(&pendings);
        sigpending(&pendings);
        showSignals(&pendings);
        sleep(1);
    }

    return 0;
}

#include <iostream>
#include <unistd.h>
#include <signal.h>
using std::cout;
using std::endl;

void handler(int signo) {
    cout << "获取到一个信号,信号的编号是: " << signo << endl;
    sigset_t pending;
    // 增加handler信号的时间,永远都会正在处理2号信号！
    while (true) {
        sigpending(&pending);
        for (int i = 1; i <= 31; i++) {
            if (sigismember(&pending, i))
                cout << '1';
            else
                cout << '0';
        }
        cout << endl;
        sleep(1);
    }
}

int main() {
    // 先定义两个 struct sigaction 用于传参
    struct sigaction act, oact;
    
    // 初始化 act
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    
    // sigaction 捕捉 2信号
    sigaction(2, &act, &oact);
    
    while (true) {
        cout << "I am a process, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

#include <iostream>
#include <signal.h>
#include <unistd.h>
using std::cout;
using std::endl;

void handler(int signo) {
    cout << "获取到一个信号,信号的编号是: " << signo << endl;
    sigset_t pending;
    // 增加handler信号的时间,永远都会正在处理2号信号！
    while (true) {
        sigpending(&pending);
        for (int i = 1; i <= 31; i++) {
            if (sigismember(&pending, i))
                cout << '1';
            else
                cout << '0';
        }
        cout << endl;
        sleep(1);
    }
}

int main() {
    // 先定义两个 struct sigaction 用于传参
    struct sigaction act, oact;

    // 初始化 act
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 3);         // 在 act.sa_mask 中设置 3信号

    // sigaction 捕捉 2信号
    sigaction(2, &act, &oact);

    while (true) {
        cout << "I am a process, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

node1->next = head;
head = node1;

#include <stdio.h>
#include <signal.h>

int flags = 0;

void handler(int signo) {
    printf("获取到一个信号,信号的编号是: %d\n", signo);
    flags = 1;
    printf("我修改了flags: 0->1\n");
}

int main() {
    signal(2, handler);

    while (!flags)
        ;
    // 未接收到信号时, flags 为 0, !flags 恒为真, 所以会死循环
    printf("此进程正常退出\n");

    return 0;
}

volatile int flags = 0; 		// 全局变量

#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <unistd.h>
using std::cout;
using std::endl;

int flags = 0;

void handler(int signo) {
    cout << "子进程退出, 我收到了信号: " << signo << "我是: " << getpid() << endl;
}

int main() {
    signal(SIGCHLD, handler);
    pid_t id = fork();
    if (id == 0) {
        // 子进程
        while (true) {
            cout << "我是子进程, pid: " << getpid() << endl;
            sleep(1);
        }
        exit(0);
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
    }

    return 0;
}

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

void freeChild(int signo) {
    assert(signo == SIGCHLD);

    pid_t id = waitpid(-1, nullptr, 0);
    if(id > 0) {
        cout << "父进程等待子进程成功, child pid: " << id << endl;
    }
}

int main() {
    signal(SIGCHLD, freeChild);
    pid_t id = fork();
    if (id == 0) {
        // 子进程
        while (true) {
            cout << "我是子进程, pid: " << getpid() << endl;
            sleep(1);
        }
        exit(0);
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

void freeChild(int signo) {
    assert(signo == SIGCHLD);

    pid_t id = waitpid(-1, nullptr, 0);
    if (id > 0) {
        cout << "父进程等待子进程成功, child pid: " << id << endl;
    }
}

int main() {
    signal(SIGCHLD, freeChild);
    for (int i = 0; i < 10; i++) {
        pid_t id = fork();
        if (id == 0) {
            // 子进程
            int cnt = 10;
            while (cnt) {
                cout << "我是子进程, pid: " << getpid() << ", cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出, 进入僵尸状态" << endl;
            exit(0);
        }
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}    

void freeChild(int signo) {
    assert(signo == SIGCHLD);

    while(true) {
        pid_t id = waitpid(-1, nullptr, 0);
        if (id > 0) {
            cout << "父进程等待子进程成功, child pid: " << id << endl;
        }
        else {
            cout << "等待结束" << endl;
            break;
        }
    }
}

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

void freeChild(int signo) {
    assert(signo == SIGCHLD);

    while (true) {
        pid_t id = waitpid(-1, nullptr, 0);
        if (id > 0) {
            cout << "父进程等待子进程成功, child pid: " << id << endl;
        }
        else {
            cout << "等待结束" << endl;
            break;
        }
    }
}

int main() {
    signal(SIGCHLD, freeChild);
    for (int i = 0; i < 10; i++) {
        pid_t id = fork();
        if (id == 0) {
            // 子进程
            int cnt = 0;
            if(i < 6)
                cnt = 5;        // 前6个子进程 5s就退出
            else
                cnt = 30;       // 后4个子进程 30s 退出
            while (cnt) {
                cout << "我是子进程, pid: " << getpid() << ", cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出, 进入僵尸状态" << endl;
            exit(0);
        }
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

void freeChild(int signo) {
    assert(signo == SIGCHLD);

    while (true) {
        pid_t id = waitpid(-1, nullptr, WNOHANG);
        if (id > 0) {
            cout << "父进程等待子进程成功, child pid: " << id << endl;
        }
        else if(id == 0){
            cout << "还有子进程在运行, 但是没有子进程退出, 父进程要去做自己的事了 " << endl;
            break;
        }
        else {
            cout << "父进程等待所有子进程结束" << endl;
            break;
        }
    }
}

int main() {
    signal(SIGCHLD, freeChild);
    // 为方便演示, 我们只创建5个子进程
    for (int i = 0; i < 5; i++) {
        pid_t id = fork();
        if (id == 0) {
            // 子进程
            int cnt = 0;
            if(i < 2)
                cnt = 5;        // 前2个子进程 5s 就退出
            else
                cnt = 30;       // 后3个子进程 30s 退出
            while (cnt) {
                cout << "我是子进程, pid: " << getpid() << ", cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出, 进入僵尸状态" << endl;
            exit(0);
        }
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using std::cout;
using std::endl;

int main() {
    signal(SIGCHLD, SIG_IGN);
    // 为方便演示, 我们只创建5个子进程
    for (int i = 0; i < 5; i++) {
        pid_t id = fork();
        if (id == 0) {
            // 子进程
            int cnt = 0;
            if(i < 2)
                cnt = 5;        // 前2个子进程 5s 就退出
            else
                cnt = 30;       // 后3个子进程 30s 退出
            while (cnt) {
                cout << "我是子进程, pid: " << getpid() << ", cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出, 进入僵尸状态" << endl;
            exit(0);
        }
    }

    // 父进程
    while (true) {
        cout << "我是父进程, pid: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}