进程的创建以及进程间的通信

　　进程是一个运行着一个或多个线程的地址空间和这些线程所需要的系统资源；通过ps -ajx命令来打印当前所有进程；其中具体状态表示为：S表示睡眠，R表示可运行，D表示等待，T表示停止，Z表示僵尸进程；PID表示进程号，PPID表示父进程号；

　　一： PID ，PPID可以通过函数getpid（），getppid（）获得， 下面是获取代码

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

int main()
{
    pid_t myself_pid = getpid();
    pid_t parent_pid = getppid();

    printf("myself_pid is %d
", myself_pid);
    printf("parent_pid is %d
", parent_pid);

    return 0;
}

　　　二： 创建一个新的进程

　　　　创建一个新的进程有三种方式：fork（）；system（）；exel ()族；

　　　 （1）system（）；

　　　　　　system（）函数调用“/bin/sh -c command”执行特定的命令，阻塞当前的进程直到command执行完毕

　　　　　　下面是通过system（）执行ls -a命令

　

#include <stdio.h>

int main()
{
    //创建一个新进程
    system("ls -a");
    printf("Over
");

    
    return 0;
}

　　　　（2）exel族包含成员（execl，execlp，execle，execv，exevp，execve）；

　　　　　　exel系列函数是替换型创建进程（子进程替换原有进程，和父进程做不同的事），只有PID保持不变（和调用exec的进程PID一样）；

　　　　　　其部分原型如下：

　　　　　　int exelc(const char *path, const char * arg, ...);

　　　　　　int execlp(const char *file, const char * arg, ...);

　　　　　　int execv(const char *path, char * const argv[ ]);

　　　　　　

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

int main()
{
    int ret = 0;
    char *argv[3] = {"ls", "-a", NULL};
    
    //创建新进程    
    ret = execv("/bin/ls", argv);
    if(ret < 0) {
        perror("execv");
        exit(EXIT_FAILURE);
    }

    printf("hello world
"); //运行程序可以看到，没有输出 "hello world"（被替换）

    return 0;
}

　　　　(3) fork();

　　　　　　一个现有进程可以调用fork（）函数创建一个新的进程， 由fork创建的进程叫做子进程，fork函数调用一次但返回两次，两次返回的唯一区别是：

　　　　　　子进程中返回的是0值，二父进程中返回的是子进程的PID

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

int main()
{
    pid_t pid = 0;
    
    pid = fork();
    if(pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    //子进程
    if(pid == 0) {
        printf("this is child pid is: %d, ppid is: %d
", getpid(), getppid());

    }
    //父进程
    if(pid > 0) {
        printf("this is parent pid is: %d, ppid is: %d
", getpid(), getppid());
    }

    printf("hello world
");//可以看到"hello world"被打印了两次（父进程，子进程）
}

　　三：下面程序是父进程给文件加一把读锁，然后进入睡眠，子进程先睡 1秒钟，然后去验证文件锁，验证子进程看到的锁文件的进程是否是父进程

　　

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

int main()
{

    pid_t pid = fork();
    if(pid > 0) {    
        printf("this is father
");
        
        //打开文件
        int fd = 0;
        fd = open("txt", O_RDWR);
        if(fd < 0) {
            perror("open");
            exit(EXIT_FAILURE);
        }

        int len = lseek(fd, 0, SEEK_END);//获取文件大小
        lseek(fd, 0, SEEK_SET);

        //父进程对文件加读锁
        struct flock lock;
        lock.l_type = F_RDLCK;
        lock.l_whence = SEEK_SET;
        lock.l_start = 0;
        lock.l_len = len;
        int ret = fcntl(fd, F_SETLK, &lock);
        if(ret < 0) {
            perror("child fcntl");
            exit(EXIT_FAILURE);
        }
        sleep(3);
        exit(EXIT_SUCCESS);
    }
    
    //子进程
    printf("child
");
    sleep(1);
    int fd = 0;
    fd = open("txt", O_RDWR);
    if(fd < 0) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    int len = lseek(fd, 0, SEEK_END);
    lseek(fd, 0, SEEK_SET);

    //子进程尝试去加写锁
    struct flock lock;
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = len;
    int ret = fcntl(fd, F_GETLK, &lock);
    if(ret < 0) {
        perror("parent fcntl");
        exit(EXIT_FAILURE);
    }

    
    printf("parent is: %d
", getppid());
    printf("lock.l_pid is: %d
", lock.l_pid);
    
    if(lock.l_type == F_RDLCK) {
        printf("read lock
");
    }
    printf("lock.l_whence is: %d
", lock.l_whence);
    printf("lock.l_len is: %d
", lock.l_len);

    close(fd);    
    exit(EXIT_SUCCESS);        
}