Linux学习笔记——进程间的通信-文件和文件锁

IPC（Inter-Process Communication，进程间通信）

系统对文件本身存在缓存机制，使用文件进行IPC的效率在某些多读少写的情况下并不低下

1.竞争条件(racing)

并发100个进程，约定好一个内容初值为0的文件，每一个进程打开文件读出数字，并且加一写回:

#include <stdio.h>#include <stdlib.h>#include <unistd.h>//提供write(),read(),lseek()函数及相关参数定义#include <errno.h>#include <fcntl.h>//提供open()函数及相关参数定义#include <string.h>#include <sys/file.h>#include <wait.h>#define COUNT 100#define NUM 64#define FILEPATH "./count"//文件的路径int do_child(const char *path)//子进程执行函数{    int fd,ret,count;    char buf[NUM];    fd = open(path,O_RDWR); //成功返回0值，不成功返回-1,可读可写的方式打开path路径的文件     if (fd<0)//若打开失败，打印返回的错误    {        perror("open()");        exit(1);//异常退出    }    ret=read(fd,buf,NUM);//成功返回读取字节数，错误返回-1    if(ret<0)    {        perror("read()");        exit(1);    }    buf[ret] = "\0";    count=atoi(buf);//字符串转换成整型数，如果第一个非空格字符不存在或者不是数字也不是正负号则返回零，否则开始做类型转换，之后检测到非数字(包括结束符 \0) 字符时停止转换，返回整型数    ++count;    sprintf(buf,"%d",count);//将整型变量count打印成字符串输出到buf中    lseek(fd,0,SEEK_SET);//将读写位置移到文件开头    ret= write(fd,buf,strlen(buf));//将buf写进文件中    close(fd);    exit(0);//正常退出}int main(){    pid_t pid;//pid_t实际上就是int，在/sys/types.h中定义    int count;    for(count=0;count<COUNT;count++)    {        pid=fork();//创建一个子进程进程，在父进程中，fork返回新创建子进程的进程ID；在子进程中，fork返回0；如果出现错误，fork返回一个负值；        if(pid<0)        {            perror("fork()");            exit(1);        }        if(pid==0)        {               do_child(FILEPATH);//创建出来的那个新进程执行任务        }    }       for(count=0;count<COUNT;count++)        wait(NULL);//等待所有进程退出   }

运行情况：

zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ echo 0 > countzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count0zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./racingzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count35zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ echo 0 > countzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./racingzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count46zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ echo 0 > countzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./racingzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count57zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ 

理想状态下，文件最后的数字应该是100,因为有100个进程进行了读数，加一，写回操作，实际上每次执行的情况都不一样，都没有达到预期理想结果，造成这一现象的原因是————竞争条件

最开始文件内容是0,假设此时同时打开了多个进程，多个进程同时打开了内容为0的文件，每个进程读到的数都是0,都给0加1并且写1回到文件。每次100个进程执行顺序可能不一样，每次结果也可能不一样，但一定少于产生的实际进程数。

把多个执行过程(进程或线程)中访问同一个共享资源，而这些共享资源又无法被多个执行过程存取的程序片段，叫做临界区代码。

通过对临界区代码加锁，解决竞争条件问题:

#include <stdio.h>#include <stdlib.h>#include <unistd.h>//提供write(),read(),lseek()函数及相关参数定义#include <errno.h>#include <fcntl.h>//提供open(),close()函数及相关参数定义#include <string.h>#include <sys/file.h>//提供flock()函数及相关参数定义#include <wait.h>#define COUNT 100#define NUM 64#define FILEPATH "./count"//文件的路径int do_child(const char *path)//子进程执行函数{    int fd,ret,count;    char buf[NUM];    fd = open(path,O_RDWR); //成功返回0值，不成功返回-1,可读可写的方式打开path路径的文件     if (fd<0)//若打开失败，打印返回的错误    {        perror("open()");        exit(1);//异常退出    }    ret=flock(fd,LOCK_EX);//LOCK_EX 建立互斥锁定;返回0表示成功，若有错误则返回-1，错误代码存于errno    if(ret==-1)    {           perror("flock()");        exit(1);    }    ret=read(fd,buf,NUM);//成功返回读取字节数，错误返回-1    if(ret<0)    {        perror("read()");        exit(1);    }    buf[ret] = "\0";    count=atoi(buf);//字符串转换成整型数，如果第一个非空格字符不存在或者不是数字也不是正负号则返回零，否则开始做类型转换，之后检测到非数字(包括结束符 \0) 字符时停止转换，返回整型数    ++count;    sprintf(buf,"%d",count);//将整型变量count打印成字符串输出到buf中    lseek(fd,0,SEEK_SET);//将读写位置移到文件开头    ret= write(fd,buf,strlen(buf));//将buf写进文件中    ret=flock(fd,LOCK_UN);//解除锁定    if(ret==-1)    {        perror("flock()");        exit(1);    }    close(fd);    exit(0);//正常退出}int main(){    pid_t pid;//pid_t实际上就是int，在/sys/types.h中定义    int count;：    for(count=0;count<COUNT;count++)    {        pid=fork();//创建一个子进程进程，在父进程中，fork返回新创建子进程的进程ID；在子进程中，fork返回0；如果出现错误，fork返回一个负值；        if(pid<0)        {            perror("fork()");            exit(1);        }        if(pid==0)        {               do_child(FILEPATH);//创建出来的那个新进程执行任务        }    }       for(count=0;count<COUNT;count++)        wait(NULL);//等待所有进程退出   }

执行情况：

zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ echo 0 > countzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count0zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./racingnzach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ cat count100zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ 

2.flock和lockf

Linux的文件锁主要有两种：flock和lockf

flock只能对整个文件加锁;
lockf是fcntl系统调用的一个封装，实现了更细粒度的文件锁————记录锁，可以对文件的部分字节上锁;

flock的语义是针对文件的锁;
lockf是针对文件描述符(fd)的锁

:

文件锁程序：

#include <stdio.h>#include <stdlib.h>#include <fcntl.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <sys/file.h>#include <wait.h>#define  PATH "./lock"int main(){        int fd;        pid_t pid;        fd=open(PATH,O_RDWR|O_CREAT|O_TRUNC,0644);//O_TRUNC:若文件存在并且以可写的方式打开时，此旗标会令文件的长度清0,存于文件的资料消失        if (fd<0)        {                perror("open()");                exit(1);        }        if(flock(fd,LOCK_EX)<0)//使用flock对其加互斥，或者if(lockf(fd,F_LOCK,0)<0)使用lockf对其加互斥锁    {               perror("flock()");            exit(1);        }        printf("%d: locked!\n",getpid());//打印表示加锁成功        pid=fork();        if(pid<0)        {                perror("fork()");                exit(1);        }        if(pid == 0)        {                fd=open(PATH,O_RDWR|O_CREAT|O_TRUNC,0644);                if(fd<0)                {                        perror("open()");                        exit(1);                }                if(flock(fd,LOCK_EX)<0)//在子进程中使用flock对同一个文件加互斥锁                {                        perror("flock()");                        exit(1);        }                printf("%d: locked!\n",getpid());//打印加锁成功                exit(0);        }        wait(NULL);        unlink(PATH);//删除指定文件        exit(0);}

运行情况:

zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./flock3544: locked!

子进程flock/lockf的时候阻塞

两种锁之间互不影响，比如以下例子

#include <unistd.h>#include <stdio.h>#include <stdlib.h>#include <sys/file.h>#include <fcntl.h>#define PATH "./lock"int main(){        int fd;        pid_t  pid;        if(open("PATH",O_RDWR|O_CREAT|O_TRUNC,0644)<0)        {                perror("open()");                exit(1);        }        if(flock(fd, LOCK_EX)<0)        {                perror("flock()");                exit(1);        }        printf("%d: Locked with flock\n",getpid());        if(lockf(fd, F_LOCK, 0)<0)        {                perror("lockf()");                exit(1);        }        printf("%d: Locked with lockf\n", getpid());        exit(0);}

执行情况如下：

zach@zach-i16:~/文档/note/Linux/进程通信/2.文件和文件锁$ ./lockf_and_flock4162: Locked with flock4162: Locked with lockf

3.标准IO库文件锁

#include <stdio.h>void flockfile(FILE *filehandle);int ftrylockfile(FILE *filehandle);void funlockfile(FILE *filehandle);

stdio库中实现的文件锁与flock或lockf有本质区别,标准IO的锁在多进程环境中使用是有问题的.

件锁只能处理一个进程中的多个线程之间共享的FILE 的进行文件操作.

多个线程必须同时操作一个用fopen打开的FILE 变量，如果内部自己使用fopen重新打开文件，那么返回的FILE *地址不同，起不到线程的互斥作用

4.小结

本次Linux进程间通信的学习是基于以下文章和书籍

穷佐罗的Linux书-Linux的进程间通信-文件和文件锁
《UNIX环境高级编程》
linux中fcntl()、lockf、flock的区别