pstree # 查看进程树状图
ps -aux # 查看所有用户的进程，-ux查看当前用户进程

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

int main(void)
{
    pid_t result;

    printf("This is a system demo!\n\n");

    /*调用 system()函数*/
    result = system("ls -l");

    printf("Done!\n\n");

    return result;
}

 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 int main(void)
 {
     pid_t result;

     printf("This is a fork demo!\n\n");

     /*调用 fork()函数*/
     result = fork();
     /*通过 result 的值来判断 fork()函数的返回情况，首先进行出错处理*/
     if(result == -1) {
         printf("Fork error\n");
     }

     /*返回值为 0 代表子进程*/
     else if (result == 0) {
         printf("The returned value is %d, In child process!! My PID is %d\n\n", result, getpid());

     }

     /*返回值大于 0 代表父进程*/
     else {
         printf("The returned value is %d, In father process!! My PID is %d\n\n", result, getpid());
     }

     return result;
 }

int main(void)
{
    int err;

    printf("this is a execl function test demo!\n\n");

    err = execl("/bin/ls", "ls", "-la", NULL);
    if (err < 0) {
        printf("execl fail!\n\n");
    }

    printf("Done!\n\n");
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    pid_t pid = fork();

    if (pid < 0) {
        perror("fork failed");
        return 1;
    }

    if (pid == 0) {
        // 子进程：用 ls 程序替换当前进程
        execl("/bin/ls", "ls", "-l", NULL);

        // exec 执行失败才会运行到这里
        perror("exec failed");
        return 1;
    } else {
        // 父进程：等待子进程结束
        wait(NULL);
        printf("child process finished\n");
    }

    return 0;
}

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

int main()
{
    pid_t pid, child_pid;
    int status;

    pid = fork();                  //(1)

    if (pid < 0) {
        printf("Error fork\n");
    }
    /*子进程*/
    else if (pid == 0) {                  //(2)

        printf("I am a child process!, my pid is %d!\n\n",getpid());

        /*子进程暂停 3s*/
        sleep(3);

        printf("I am about to quit the process!\n\n");

        /*子进程正常退出*/
        exit(0);                          //(3)
    }
    /*父进程*/
    else {                                //(4)

        /*调用 wait，父进程阻塞*/
        child_pid = wait(&status);        //(5)

        /*若发现子进程退出，打印出相应情况*/
        if (child_pid == pid) {
            printf("Get exit child process id: %d\n",child_pid);
            printf("Get child exit status: %d\n\n",status);
        } else {
            printf("Some error occured.\n\n");
        }

        exit(0);
    }
}

cat@lubancat ~> kill -l
HUP INT QUIT ILL TRAP ABRT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STKFLT
CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH POLL PWR SYS

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

int main(void)
{
    printf("\nthis is an singal test function\n\n");

    while (1) {
        printf("waiting for the SIGINT signal , please enter \"ctrl + c\"...\n");
        sleep(1);
    }

    exit(0);
}

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

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

/** 信号处理函数 */
void signal_handler(int sig)           
{
    printf("\nthis signal number is %d \n",sig);

    if (sig == SIGINT) {
        printf("I have get SIGINT!\n\n");
        printf("The signal has been restored to the default processing mode!\n\n");
        /** 恢复信号为默认情况 */
        signal(SIGINT, SIG_DFL);        
    }

}

int main(void)
{
    printf("\nthis is an singal test function\n\n");

    /** 设置信号处理的回调函数 */
    signal(SIGINT, signal_handler);         

    while (1) {
        printf("waiting for the SIGINT signal , please enter \"ctrl + c\"...\n");
        sleep(1);                          
    }

    exit(0);
}

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

struct sigaction {
            void     (*sa_handler)(int);
            void     (*sa_sigaction)(int, siginfo_t *, void *);
            sigset_t   sa_mask;
            int        sa_flags;
            void     (*sa_restorer)(void);
        };

siginfo_t {
            int      si_signo;     /* 信号数值 */
            int      si_errno;     /* 错误值 */
            int      si_code;      /* 信号代码 */
            int      si_trapno;   /*导致硬件生成信号的陷阱号，在大多数体系结构中未使用*/
            pid_t    si_pid;       /* 发送信号的进程ID */
            uid_t    si_uid;       /*发送信号的真实用户ID */
            int      si_status;    /* 退出值或信号状态*/
            clock_t  si_utime;     /*消耗的用户时间*/
            clock_t  si_stime;     /*消耗的系统时间*/
            sigval_t si_value;     /*信号值*/
            int      si_int;       /* POSIX.1b 信号*/
            void    *si_ptr;
            int      si_overrun;   /*计时器溢出计数*/
            int      si_timerid;   /* 计时器 ID */
            void    *si_addr;      /*导致故障的内存位置 */
            long     si_band;
            int      si_fd;        /* 文件描述符*/
            short    si_addr_lsb;  /*地址的最低有效位 (从Linux 2.6.32开始存在) */
            void    *si_lower;     /*地址冲突时的下限*/
            void    *si_upper;     /*地址冲突时的上限 (从Linux 3.19开始存在) */
            int      si_pkey;      /*导致的PTE上的保护密钥*/
            void    *si_call_addr; /*系统调用指令的地址*/
            int      si_syscall;   /*尝试的系统调用次数*/
            unsigned int si_arch;  /* 尝试的系统调用的体系结构*/
        }

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

/** 信号处理函数 */
void signal_handler(int sig)                    //(1)
{
    printf("\nthis signal number is %d \n",sig);

    if (sig == SIGINT) {
        printf("I have get SIGINT!\n\n");
        printf("The signal is automatically restored to the default handler!\n\n");
        /** 信号自动恢复为默认处理函数 */
    }

}

int main(void)
{
    struct sigaction act;

    printf("this is sigaction function test demo!\n\n");

    /** 设置信号处理的回调函数 */
    act.sa_handler = signal_handler;            //(2)

    /* 清空屏蔽信号集 */
    sigemptyset(&act.sa_mask);                  //(3)

    /** 在处理完信号后恢复默认信号处理 */
    act.sa_flags = SA_RESETHAND;                //(4)

    sigaction(SIGINT, &act, NULL);              //(5)

    while (1)
    {
        printf("waiting for the SIGINT signal , please enter \"ctrl + c\"...\n\n");
        sleep(1);
    }

    exit(0);
}

kill [信号或选项] PID(s)

int kill(pid_t pid, int sig);

int raise(int sig);

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

int main(void)
{
    pid_t pid;

    int ret;

    /* 创建一子进程 */
    if ((pid = fork()) < 0) {               
        printf("Fork error\n");
        exit(1);
    }

    if (pid == 0) {                         
        /* 在子进程中使用 raise()函数发出 SIGSTOP 信号,使子进程暂停 */
        printf("Child(pid : %d) is waiting for any signal\n\n", getpid());

        /** 子进程停在这里 */
        raise(SIGSTOP);                    

        exit(0);
    }

    else {                                 
        /** 等待一下，等子进程先执行 */
        sleep(1);

        /* 在父进程中收集子进程发出的信号(不阻塞)，并调用 kill()函数进行相应的操作 */
        if ((waitpid(pid, NULL, WNOHANG)) == 0) {       
            /** 子进程还没退出，返回为0，就发送SIGKILL信号杀死子进程 */
            if ((ret = kill(pid, SIGKILL)) == 0) {
                printf("Parent kill %d\n\n",pid);       
            }
        }

        /** 一直阻塞直到子进程退出（杀死） */
        waitpid(pid, NULL, 0);              

        exit(0);
    }
}

unsigned int alarm(unsigned int seconds);

int main()
{
    printf("\nthis is an alarm test function\n\n");
    alarm(5); // SIGALRM的默认处理为执行exit(0)
    sleep(20);
    printf("end!\n");
    return 0;
}

ps -ux | grep $USER

int pipe(int pipefd[2]);

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

#define MAX_DATA_LEN 256
#define DELAY_TIME 1

int main()
{
 pid_t pid;
 int pipe_fd[2];                             //(1)
 char buf[MAX_DATA_LEN];
 const char data[] = "Pipe Test Program";
 int real_read, real_write;

 memset((void*)buf, 0, sizeof(buf));

 /* 创建管道 */
 if (pipe(pipe_fd) < 0)                  //(2)
 {
	 printf("pipe create error\n");
	 exit(1);
 }

 /* 创建一子进程 */
 if ((pid = fork()) == 0)                //(3)
 {
	 /* 子进程关闭写描述符，并通过使子进程暂停 3s 等待父进程已关闭相应的读描述符 */
	 close(pipe_fd[1]);
	 sleep(DELAY_TIME * 3);

	 /* 子进程读取管道内容 */            //(4)
	 if ((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0)
	 {
		 printf("%d bytes read from the pipe is '%s'\n", real_read, buf);
	 }

	 /* 关闭子进程读描述符 */
	 close(pipe_fd[0]);                  //(5)

	 exit(0);
 }

 else if (pid > 0)
 {
	 /* 父进程关闭读描述符，并通过使父进程暂停 1s 等待子进程已关闭相应的写描述符 */
	 close(pipe_fd[0]);                  //(6)

	 sleep(DELAY_TIME);

	 if((real_write = write(pipe_fd[1], data, strlen(data))) != -1)  //(7)
	 {
		 printf("Parent write %d bytes : '%s'\n", real_write, data);
	 }

	 /*关闭父进程写描述符*/
	 close(pipe_fd[1]);                  //(8)

	 /*收集子进程退出信息*/
	 waitpid(pid, NULL, 0);              //(9)

	 exit(0);
 }
}

int mkfifo(const char * pathname,mode_t mode);

#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

#define MYFIFO "myfifo"    /* 命名管道文件名*/

#define MAX_BUFFER_SIZE PIPE_BUF /* 4096 定义在于 limits.h 中*/

void fifo_read(void)
{
 char buff[MAX_BUFFER_SIZE];
 int fd;
 int nread;

 printf("***************** read fifo ************************\n");
 /* 判断命名管道是否已存在，若尚未创建，则以相应的权限创建*/
 if (access(MYFIFO, F_OK) == -1)                 //(4)
 {
	 if ((mkfifo(MYFIFO, 0666) < 0) && (errno != EEXIST))    //(5)
	 {
		 printf("Cannot create fifo file\n");
		 exit(1);
	 }
 }

 /* 以只读阻塞方式打开命名管道 */
 fd = open(MYFIFO, O_RDONLY);                //(6)
 if (fd == -1)
 {
	 printf("Open fifo file error\n");
	 exit(1);
 }

 memset(buff, 0, sizeof(buff));

 if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0)      // (7)
 {
	 printf("Read '%s' from FIFO\n", buff);
 }

printf("***************** close fifo ************************\n");

 close(fd);                              //(8)

 exit(0);
}

void fifo_write(void)
{
 int fd;
 char buff[] = "this is a fifo test demo";
 int nwrite;

 sleep(2);   //等待子进程先运行              //(9)

 /* 以只写阻塞方式打开 FIFO 管道 */
 fd = open(MYFIFO, O_WRONLY | O_CREAT, 0644);        //(10)
 if (fd == -1)
 {
	 printf("Open fifo file error\n");
	 exit(1);
 }

 printf("Write '%s' to FIFO\n", buff);

 /*向管道中写入字符串*/
 nwrite = write(fd, buff, sizeof(buff));          //(11)

 if(wait(NULL))  //等待子进程退出
 {
	 close(fd);                          //(12)
	 exit(0);
 }

}

int main()
{
 pid_t result;
 /*调用 fork()函数*/
 result = fork();                //(1)

 /*通过 result 的值来判断 fork()函数的返回情况，首先进行出错处理*/
 if(result == -1)
 {
	 printf("Fork error\n");
 }

 else if (result == 0) /*返回值为 0 代表子进程*/
 {
	 fifo_read();            //(2)
 }

 else /*返回值大于 0 代表父进程*/
 {
	 fifo_write();       //(3)
 }

 return result;
}

int msgget(key_t key, int msgflg);

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 512

struct message
{
    long msg_type;
    char msg_text[BUFFER_SIZE];
};
int main()
{
    int qid;
    struct message msg;

    /*创建消息队列*/    if ((qid = msgget((key_t)1234, IPC_CREAT|0666)) == -1)
    {
        perror("msgget\n");
        exit(1);
    }

    printf("Open queue %d\n",qid);

    while(1)
    {
        printf("Enter some message to the queue:");
        if ((fgets(msg.msg_text, BUFFER_SIZE, stdin)) == NULL)
        {
            printf("\nGet message end.\n");
            exit(1);
        }

        msg.msg_type = getpid();
        /*添加消息到消息队列*/        if ((msgsnd(qid, &msg, strlen(msg.msg_text), 0)) < 0)
        {
            perror("\nSend message error.\n");
            exit(1);
        }
        else
        {
            printf("Send message.\n");
        }
        if (strncmp(msg.msg_text, "quit", 4) == 0)
        {
            printf("\nQuit get message.\n");
            break;
        }
    }

    exit(0);
}

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 512

struct message
{
    long msg_type;
    char msg_text[BUFFER_SIZE];
};

int main()
{
    int qid;
    struct message msg;

    /*创建消息队列*/
    if ((qid = msgget((key_t)1234, IPC_CREAT|0666)) == -1)    {
        perror("msgget");
        exit(1);
    }

    printf("Open queue %d\n", qid);

    do
    {
        /*读取消息队列*/
        memset(msg.msg_text, 0, BUFFER_SIZE);

        if (msgrcv(qid, (void*)&msg, BUFFER_SIZE, 0, 0) < 0)        {
            perror("msgrcv");
            exit(1);
        }

        printf("The message from process %ld : %s", msg.msg_type, msg.msg_text);

    } while(strncmp(msg.msg_text, "quit", 4));

    /*从系统内核中删除消息队列 */
    if ((msgctl(qid, IPC_RMID, NULL)) < 0)    {
        perror("msgctl");
        exit(1);
    }
    else
    {
        printf("Delete msg qid: %d.\n", qid);
    }

    exit(0);

}

int semget(key_t key, int nsems, int semflg);

watermeko@DESKTOP-2ER8RB2 ~> ipcs -l

------ Semaphore Limits --------
max number of arrays = 32000
max semaphores per array = 32000
max semaphores system wide = 1024000000
max ops per semop call = 500
semaphore max value = 32767

int semop(int semid, struct sembuf *sops, size_t nsops);

struct sembuf {
 unsigned short int sem_num;
 short int sem_op;
 short int sem_flg;
};

int semctl(int semid, int semnum, int cmd, ...);

#include <sys/sem.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include "sem.h"

int init_sem(int sem_id, int init_value)
{
    union semun sem_union;    sem_union.val = init_value; 

    if (semctl(sem_id, 0, SETVAL, sem_union) == -1)    {
        perror("Initialize semaphore");
        return -1;
    }

    return 0;
}

int del_sem(int sem_id)
{
    union semun sem_union;
    if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)    {
        perror("Delete semaphore");
        return -1;
    }
}

int sem_p(int sem_id)
{
    struct sembuf sops;
    sops.sem_num = 0;
    sops.sem_op = -1;    
    sops.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sops, 1) == -1)    {
        perror("P operation");
        return -1;
    }
    return 0;
}

int sem_v(int sem_id)
{
    struct sembuf sops;
    sops.sem_num = 0;
    sops.sem_op = 1;   
    sops.sem_flg = SEM_UNDO; 

    if (semop(sem_id, &sops, 1) == -1)    {
        perror("V operation");
        return -1;
    }
    return 0;
}

#include <sys/types.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include "sem.h"

#define DELAY_TIME 3 

int main(void)
{
    pid_t result;
    int sem_id;

    sem_id = semget((key_t)6666, 1, 0666 | IPC_CREAT);
    init_sem(sem_id, 0);

    result = fork();
    if(result == -1)
    {
        perror("Fork\n");
    }
    else if (result == 0){
        printf("Child process will wait for some seconds...\n");
        sleep(DELAY_TIME);
        printf("The returned value is %d in the child process(PID = %d)\n",result, getpid());

        sem_v(sem_id);
    }

    else{
        sem_p(sem_id);
        printf("The returned value is %d in the father process(PID = %d)\n",result, getpid());

        sem_v(sem_id);

        del_sem(sem_id);
    }

    exit(0);
}

int shmget(key_t key, size_t size, int shmflg);

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

struct shmid_ds {
    struct ipc_perm shm_perm;    /* 所有权和权限 */
    size_t          shm_segsz;   /* 共享内存尺寸（字节） */
    time_t          shm_atime;   /* 最后一次映射时间 */
    time_t          shm_dtime;   /* 最后一个解除映射时间 */
    time_t          shm_ctime;   /* 最后一次状态修改时间 */
    pid_t           shm_cpid;    /* 创建者PID */
    pid_t           shm_lpid;    /* 后一次映射或解除映射者PID */
    shmatt_t        shm_nattch;  /* 映射该SHM的进程个数 */
    ...
};

struct ipc_perm {
    key_t          __key;    /* 该共享内存的键值key */
    uid_t          uid;      /* 所有者的有效UID */
    gid_t          gid;      /* 所有者的有效GID */
    uid_t          cuid;     /* 创建者的有效UID */
    gid_t          cgid;     /* 创建者的有效GID */
    unsigned short mode;     /* 读写权限 + SHM_DEST + SHM_LOCKED 标记 */
    unsigned short __seq;    /* 序列号 */
};

#include <sys/types.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include "sem.h"

int main()
{
    int running = 1;
    void *shm = NULL;
    struct shared_use_st *shared = NULL;
    char buffer[BUFSIZE + 1];
    int shmid;
    int semid;

    shmid = shmget((key_t)1234, 4096, 0644 | IPC_CREAT);
	if(shmid == -1)
    {
        fprintf(stderr, "shmget failed\n");
        exit(EXIT_FAILURE);
    }

    shm = shmat(shmid, (void*)0, 0);    
    if(shm == (void*)-1)
    {
        fprintf(stderr, "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("Memory attached at %p\n", shm);

    semid = semget((key_t)6666, 1, 0666|IPC_CREAT);

    if(semid == -1)
    {
        printf("sem open fail\n");
        exit(EXIT_FAILURE);
    }

    while(running)
    {
        printf("Enter some text: ");
        fgets(buffer, BUFSIZE, stdin);
        strncpy(shm, buffer, 4096);
        sem_v(semid);

        if(strncmp(buffer, "end", 3) == 0)
            running = 0;
    }

    if(shmdt(shm) == -1)    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }
    sleep(2);
    exit(EXIT_SUCCESS);
}

#include <sys/types.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#include "sem.h"

int main(void)
{
    int running = 1;
    char *shm = NULL;
    int shmid;
    int semid;

    shmid = shmget((key_t)1234, 4096, 0666 | IPC_CREAT);    
    if(shmid == -1)
    {
        fprintf(stderr, "shmget failed\n");
        exit(EXIT_FAILURE);
    }

    shm = shmat(shmid, 0, 0);    
    if(shm == (void*)-1)
    {
        fprintf(stderr, "shmat failed\n");
        exit(EXIT_FAILURE);
    }
    printf("\nMemory attached at %p\n", shm);

    semid = semget((key_t)6666, 1, 0666|IPC_CREAT); 
    if(semid == -1)
    {
        printf("sem open fail\n");
        exit(EXIT_FAILURE);
    }

    init_sem(semid, 0);

    while(running)
    {
        if(sem_p(semid) == 0)
        {
            printf("You wrote: %s", shm);            
            sleep(rand() % 3);

            if(strncmp(shm, "end", 3) == 0)
                running = 0;
        }
    }

    del_sem(semid);

    if(shmdt(shm) == -1)
    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }

    if(shmctl(shmid, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

typedef struct
{
    int                   detachstate;      //线程的分离状态
    int                   schedpolicy;     //线程调度策略
    struct sched_param     schedparam;      //线程的调度参数
    int                   inheritsched;    //线程的继承性
    int                   scope;           //线程的作用域
    size_t                guardsize;       //线程栈末尾的警戒缓冲区大小
    int                   stackaddr_set;   //线程的栈设置
    void*                 stackaddr;       //线程栈的位置
    size_t                stacksize;       //线程栈的大小
}pthread_attr_t;

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

/*要执行的线程*/
void *test_thread(void *arg)
{
    int num = (unsigned long long)arg; /** sizeof(void*) == 8 and sizeof(int) == 4 (64 bits) */

    printf("This is test thread, arg is %d\n", num);
    sleep(5);
    /*退出线程*/
    pthread_exit(NULL);
}

int main(void)
{
    pthread_t thread;
    void *thread_return;
    int arg = 520;
    int res;

    printf("start create thread\n");

    /*创建线程，线程为test_thread函数*/
    res = pthread_create(&thread, NULL, test_thread, (void*)(unsigned long long)(arg));
    if(res != 0)
    {
        printf("create thread fail\n");
        exit(res);
    }

    printf("create threads success\n");
    printf("waiting for threads to finish...\n");

    /*等待线程终止*/
    res = pthread_join(thread, &thread_return);    if(res != 0)
    {
        printf("thread exit fail\n");
        exit(res);
    }

    printf("thread exit ok\n");

    return 0;
}

int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

static int glob = 0;
static sem_t sem;

static void *threadFunc(void *arg) {
    int loops = *((int *) arg);
    int loc, j;

    for (j = 0; j < loops; j++) {
        // P操作: 申请资源，如果信号量值为0则阻塞
        if (sem_wait(&sem) == -1) {
            perror("sem_wait");
            return NULL;
        }

        // --- 临界区开始 ---
        loc = glob;
        loc++;
        glob = loc;
        // --- 临界区结束 ---

        // V操作: 释放资源，并唤醒等待的线程
        if (sem_post(&sem) == -1) {
            perror("sem_post");
            return NULL;
        }
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t t1, t2;
    int loops = 10000000; // 循环次数

    // 初始化无名信号量
    // 参数2 (pshared): 0 表示用于线程间同步
    // 参数3 (value): 1，初始资源数为1，相当于互斥锁
    if (sem_init(&sem, 0, 1) == -1) {
        perror("sem_init");
        return 1;
    }

    pthread_create(&t1, NULL, threadFunc, &loops);
    pthread_create(&t2, NULL, threadFunc, &loops);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("glob = %d\n", glob); // 结果总是20000000
    sem_destroy(&sem);           // 销毁信号量

    return 0;
}

// 编译时通常需要链接 rt 库: gcc your_program.c -lrt
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <unistd.h>

#define MAX_PROC 5

int main() {
    int shm_id;
    sem_t *sem_p;
    pid_t pid;

    // 1. 创建共享内存段
    shm_id = shmget(IPC_PRIVATE, sizeof(sem_t), IPC_CREAT | 0666);
    if (shm_id == -1) {
        perror("shmget failed");
        exit(1);
    }

    // 2. 将共享内存附加到本进程地址空间
    sem_p = (sem_t *)shmat(shm_id, NULL, 0);
    if (sem_p == (void *)-1) {
        perror("shmat failed");
        exit(1);
    }

    // 3. 在共享内存上初始化无名信号量
    // 参数2 (pshared): 1，表示该信号量将在进程间共享
    // 参数3 (value): 1，初始资源数为1
    if (sem_init(sem_p, 1, 1) == -1) {
        perror("sem_init failed");
        exit(1);
    }

    for (int i = 0; i < MAX_PROC; i++) {
        pid = fork();
        if (pid == 0) { // 子进程
            // 子进程同样通过附加的地址 sem_p 来访问信号量
            printf("子进程 %d 正在等待进入临界区...\n", getpid());
            sem_wait(sem_p);   // 申请进入
            printf("子进程 %d 已进入临界区，工作中...\n", getpid());
            sleep(1);          // 模拟工作
            printf("子进程 %d 退出临界区\n", getpid());
            sem_post(sem_p);   // 释放资源
            exit(0);
        } else if (pid < 0) {
            perror("fork failed");
        }
    }

    // 父进程等待所有子进程结束
    for (int i = 0; i < MAX_PROC; i++) {
        wait(NULL);
    }

    // 清理工作
    sem_destroy(sem_p);
    shmdt(sem_p);
    shmctl(shm_id, IPC_RMID, NULL);
    return 0;
}

watermeko@DESKTOP-2ER8RB2 ~/D/linux_learn> ./test
子进程 184410 正在等待进入临界区...
子进程 184410 已进入临界区，工作中...
子进程 184411 正在等待进入临界区...
子进程 184412 正在等待进入临界区...
子进程 184413 正在等待进入临界区...
子进程 184414 正在等待进入临界区...
子进程 184410 退出临界区
子进程 184411 已进入临界区，工作中...
子进程 184411 退出临界区
子进程 184412 已进入临界区，工作中...
子进程 184412 退出临界区
子进程 184413 已进入临界区，工作中...
子进程 184413 退出临界区
子进程 184414 已进入临界区，工作中...
子进程 184414 退出临界区

sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
int sem_wait(sem_t *sem); // P操作
int sem_trywait(sem_t *sem); // 非阻塞wait
int sem_post(sem_t *sem);
int sem_close(sem_t *sem);
int sem_unlink(const char *name);

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

int main() {
    // 创建或打开一个名为 "/my_sem" 的信号量，初始值为 0
    // 位于/dev/shm/sem.my_sem
    sem_t *sem = sem_open("/my_sem", O_CREAT, 0644, 0);
    if (sem == SEM_FAILED) {
        perror("sem_open failed");
        return 1;
    }

    printf("进程1: 等待进程2的信号...\n");
    sem_wait(sem); // 阻塞，等待信号量值变为正
    printf("进程1: 收到信号，继续执行!\n");

    sem_close(sem);
    return 0;
}