c(4)文件锁+进程

最新推荐文章于 2023-10-24 18:52:57 发布
最新推荐文章于 2023-10-24 18:52:57 发布
阅读量362 收藏
点赞数
分类专栏： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mengbabe_2018/article/details/80536211
版权
1）文件锁

为了避免在读写同一个文件的同一个区域时发生冲突，进程之间应该遵循以下规则：如果一个进程正在写，那么其他进程既不能写也不能读；如果一个进程正在读，那么其他进程不能写但是可以读。


2）
文件元数据（文件属性信息）

//node.c

输出：

-rrSr-rr--

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
//得到文件类型、权限等信息
const char *mtos(mode_t m){
	static char s[11];
	if(S_ISDIR(m))//是否目录
	    strcpy(s,"d");
	else if(S_ISSOCK(m))//是否本地套接字
	    strcpy(s,"s");
	else if(S_ISCHR(m))//是否字符设备
	    strcpy(s,"c");
	else if(S_ISBLK(m))//是否块设备
	    strcpy(s,"b");
	else if(S_ISLNK(m))//是否符号链接
	    strcpy(s,"l");
	else if(S_ISFIFO(m))//是否有名管道
	    strcpy(s,"p");
	else
	    strcpy(s,"-");//是否普通文件
	//用户读、写、执行
	strcat(s,m&S_IRUSR?"r":"-");
	strcat(s,m&S_IWUSR?"r":"-");
	strcat(s,m&S_IXUSR?"r":"-");
	//组成员读、写、执行
	strcat(s,m&S_IRGRP?"r":"-");
	strcat(s,m&S_IWGRP?"r":"-");
	strcat(s,m&S_IXGRP?"r":"-");
	//其他人读、写、执行
	strcat(s,m&S_IROTH?"r":"-");
	strcat(s,m&S_IWOTH?"r":"-");
	strcat(s,m&S_IXOTH?"r":"-");
	if(m&S_ISUID)//用户ID
	    s[3]=(s[3]=='x'?'s':'S');
	if(m&S_ISGID)//组ID
	    s[3]=(s[3]=='x'?'s':'S');
	if(m&S_ISVTX)//粘滞位
	    s[3]=(s[3]=='x'?'s':'S');
	return s;
}
int main(){
	int fd=open("data.txt",O_RDWR,0666);
	if(fd==-1){
		perror("open");
		exit(EXIT_FAILURE);
	}
	struct stat statdata;
	fstat(fd,&statdata);//用函数fstat提取文件fd的元数据
	printf("%s\n",mtos(statdata.st_mode));
	if(close(fd)==-1){
		perror("close");
		exit(EXIT_FAILURE);
	}
}

硬链接：[link函数]

本质就是目录文件里一个文件名和i节点号的对应条目，通过该节点，就可以根据一个文件的文件名迅速地找到与之相对应的节点号，进而访问该文件的数据。
软链接（符号链接）：[symlink函数]
本质就是一个保存着另一个文件或目录的路径的文件。所有针对符号链接文件的访问，最后都会被定向到该符号链接所引用的目标文件或目录。


3）

创建子进程

//02pid.c

输出：

执行fork前带有换行符
执行fork前没有换行符 这是子进程，pid=3472,父进程的pid=3471
,pid=3472,glob=7,var=89
[停顿10秒]执行fork前没有换行符 这是父进程，pid=3471
pid=3471,glob=6,var=88

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int glob=6;
int main(){
	int var=88;
	pid_t pid;
//调用fork函数前的代码只有父进程执行，fork函数成功返回后
//的代码子进程和父进程都会执行，受逻辑控制进入不同分支。
//printf函数带\n和不带\n是有区别的，因为不带\n时，并不是马上
//更新显示缓冲区，所以造成好像子和父进程都执行了此语句的假象
	printf("执行fork前带有换行符\n");
	printf("执行fork前没有换行符 ");
	if((pid=fork())<0){
		perror("fork");
	}//fork函数创建子进程，调用一次，在子进程和父进程中各
	//返回一次，在子进程中返回所创建子进程的PID，而在子进程
	//中返回0
	else if(pid==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n,",getppid());
		glob++;
		var++;
	}
	else{
		sleep(10);
		printf("这是父进程，pid=%d\n",getpid());
	}
	printf("pid=%d,glob=%d,var=%d\n",getpid(),glob,var);
	return 0;
}

创建轻量级子进程
vfork函数创建的子进程不复制父进程的物理内存，也不拥有自己独立的内存映射，而是与父进程共享全部地址空间。vfork函数会在创建子进程的同时挂起其父进程，直到子进程终止，或通过exec函数启动了另一个可执行程序。

//05vfork.c

输出：

父进程开始执行。
子进程开始执行。
excel: No such file or directory
[停顿1秒]父进程执行结束。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
	printf("父进程开始执行。\n");
	pid_t pid=vfork();
	if(pid==-1){
		perror("vfock");
		exit(EXIT_FAILURE);
	}
	if(pid==0){
		printf("子进程开始执行。\n");
		if(execl("ls","ls","-l",NULL)==-1){
			perror("excel");
			_exit(EXIT_FAILURE);
		}
	}
	sleep(1);
	printf("父进程执行结束。\n");
	return 0;
}



父子进程共享文件表
fork函数成功返回后，系统内核维护的文件描述符也被复制到子进程的进程表项中，文件表项并不复制，所以子进程和父进程写入统一文件

//04fork.c

输出：

111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024
111111111->0,buf[0]=0,writed=1024

......


data.txt内容：

111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111    111111111111111111111111111111111111111111111111111111111111111111111

......

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <stdbool.h>
#define BUFSIZE 1024*1024
bool lock(int fd){
	struct flock lock;
	lock.l_type=F_WRLCK;
	lock.l_whence=SEEK_SET;
	lock.l_start=0;
	lock.l_len=0;
	lock.l_pid=-1;
	if(fcntl(fd,F_SETLK,&lock)==-1){
		if(errno!=EAGAIN){
			perror("fcntl");
			exit(EXIT_FAILURE);
		}
		return false;
	}
	return true;
}
void unlock(int fd){
	struct flock lock;
	lock.l_type=F_UNLCK;
	lock.l_whence=SEEK_SET;
	lock.l_start=0;
	lock.l_len=0;
	lock.l_pid=-1;
	if(fcntl(fd,F_SETLKW,&lock)==-1){
		perror("fcntl");
		exit(EXIT_FAILURE);
	}
}
//函数writedata向文件fd写入数据
void writedata(int fd,char *buf,char c){
	while(!lock(fd));//设置写锁，防止子进程和父进程同时写入造成数据混乱
	for(int i=0;i<BUFSIZE-1;i++)
	    buf[i]=c;
	for(int i=0;i<1024;i++){
	    	int writed;
		if((writed=write(fd,buf+i,1024))==-1){
			perror("write");
			exit(EXIT_FAILURE);
		}
		printf("111111111->%c,buf[0]=%c,writed=%d\n",c,*(buf+i),writed);
	}
	unlock(fd);
}
int main(){
	int fd=open("data.txt",O_RDWR|O_CREAT|O_TRUNC,0666);
	if(fd==-1){
		perror("open");
		exit(EXIT_FAILURE);
	}
	pid_t pid;
	if((pid=fork())<0){
		perror("fork");
		return 1;
	}
	if(pid==0){//子进程向文件中写入0
		char buf[BUFSIZE]={};
		writedata(fd,buf,'0');
	}
	else{//父进程向文件中写入1
		char buf[BUFSIZE]={};
		writedata(fd,buf,'1');
	}
	if(close(fd)==-1){
		perror("close");
		exit(EXIT_FAILURE);
	}
	return 0;
}


4）
孤儿与僵尸
孤儿：
子进程被暂停了10秒钟，所以当父进程退出时，子进程仍然未退出。这样子进程即成为孤儿进程。当暂停的10秒钟结束时，子进程的父进程变成了1，即init进程，又被称为孤儿院进程。

//01.c

输出：

y@y-Lenovo-ideapad-310S-14IKB:~/case8$ ./a.out
这是父进程，pid=3686[等待10秒]
y@y-Lenovo-ideapad-310S-14IKB:~/case8$ 这是子进程，pid=3687父进程的pid=1221[进程未退出]

^C

/孤儿进程
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(void){
	pid_t pid;
	if((pid=fork())<0){
		perror("fork");
	}
	else if(pid==0){
		sleep(10);
		printf("这是子进程，pid=%d",getpid());
		printf("父进程的pid=%d\n",getppid());
	}
	else{
		printf("这是父进程，pid=%d\n",getpid());
	}
	return 0;
}
僵尸：
指定父进程休眠的秒数，在这10秒内，子进程已经退出，而父进程休眠，不可能对它进行收集，这样，我们就能获得10秒的僵尸状态。
//02.c

输出：

这是子进程，pid=3722父进程的pid=3721[等待10秒]

这是父进程，pid=3721

//僵尸进程
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(void){
	pid_t pid;
	if((pid=fork())<0){
		perror("fork");
	}
	else if(pid==0){
		printf("这是子进程，pid=%d",getpid());
		printf("父进程的pid=%d\n",getppid());
	}
	else{
	    	sleep(10);
		printf("这是父进程，pid=%d\n",getpid());
	}
	return 0;
}

5）
进程的正常终止
<stdlib.h>
void exit(int status);
int atexit(void (*function)(void));
int on_exit(void (*function)(int , void *), void *arg);

void exit(int status);
exit函数调用，立即令调用进程终止

int atexit(void (*function)(void));

函数atxit为注册退出处理函数，该函数有一个参数是退出处理函数指针，所指向的函数必须既无返回值亦无参数，在进程终止前被调用，为进程料理临终事宜。atexit函数本身并不调用退出处理函数指针，只是将doexit参数所表示的退出处理函数地址，保存（注册）在系统内核的某个地方（进程表项）。待到exit函数被调用或在main函数里执行return语句时，再由系统内核根据这些退出处理函数的地址来调用它们，此过程亦称回调。

//06atexit.c
输出：
主函数退出了。

注册的退出处理函数被调用了。

#include <stdio.h>
#include <stdlib.h>
void doexit(){
	printf("注册的退出处理函数被调用了。\n");
}
int main(){
	atexit(doexit);
	printf("主函数退出了。\n");
	return 0;
}


int on_exit(void (*function)(int , void *), void *arg);

使用函数on_exit注册退出处理函数，该函数有两个参数，第一个参数为退出处理函数指针，所指向的函数必须无返回值但有两个参数。其中一个参数来自传递给exit函数的statues参数或在main函数里执行return语句的返回值，而第二个参数则来自传递给on_exit函数的arg参数。该函数在进程终止前被调用，为进程料理临终事宜。第二个参数为泛型指针，将作为第二个参数传递给function所指向的退出处理函数。

//06on_exit.c
输出：
主函数退出了。

注册的退出处理函数被调用了。

#include <stdio.h>
#include <stdlib.h>
//定义退出处理函数，用作退出处理函数，处理函数退出前必做的一些工作
void doexit(int status,void *arg){
	printf("%s",(char *)arg);
}
int main(){
	on_exit(doexit,"注册的退出处理函数被调用了。\n");
	printf("主函数退出了。\n");
	return 0;
}


[_exit、_Exit和exit的区别：

_exit、_Exit函数和exit函数一样也是正常终止调用，但它们影响的完全是调用进程自己的资源，与其父进程没有任何关系。在用vfork函数创建的子进程存在太多与其父进程共享的资源。如果在子进程里调用了exit函数或在子进程的main函数里执行了return语句（这二者在本质上是等价的），不仅销毁了子进程的资源，同时也销毁了父进程的资源，而父进程恰恰要在子进程终止以后从挂起中恢复运行，其后果可想而知。
]


6）
<sys/types.h>
<sys/wait.h>
pid_t wait(int *wstatus);
pid_t waitpid(pid_t pid, int *wstatus, int options);

回收任意或所有子进程
pid_t wait(int *wstatus);
父进程在创建若干子进程以后调用wait函数，此时若所有子进程都在运行，则wait阻塞，直至有子进程终止；若有一个子进程已终止，则wait返回该子进程的PID并通过status参数（若非NULL）输出其终止状态；若没有需要等待的子进程，则wait返回-1,置errno为ECHILD。
//07.c
输出：
这是父进程，pid=5926
这是子进程，pid=5928,父进程的pid=5926
这是子进程，pid=5927,父进程的pid=5926

5927子进程终止5928子进程终止子进程都死光了

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <errno.h>
int main(){
	pid_t pid1;
	if((pid1=fork())<0)
	    perror("fork");
	if(pid1==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n",getppid());
		_exit(0);
	}
	pid_t pid2;
	if((pid2=fork())<0)
	    perror("fork");
	if(pid2==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n",getppid());
		_exit(0);
	}
	printf("这是父进程，pid=%d\n",getpid());
	//等待并回收所有子进程，忽略其终止状态。
	while(1){
		pid_t pid=wait(NULL);
		if(pid==-1){
			if(errno!=ECHILD){
				perror("wait");
				exit(EXIT_FAILURE);
			}
			printf("子进程都死光了\n");
			break;
		}
		printf("%d子进程终止",pid);
	}
	return 0;
}


非阻塞模式回收所有子进程

pid_t waitpid(pid_t pid, int *wstatus, int options);
wstatus为输出子进程的终止状态，可置NULL
options=0,阻塞模式
options=WNOHANG,非阻塞模式
使用函数waitpid以非阻塞方式回收任意子进程
//09.c
输出：
这是父进程，pid=6420
在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处�这是子进程，pid=6422,父进程的pid=6420
这是子进程，pid=6421,父进程的pid=6420
��在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理在这里进行空闲处理6421子进程终止
6422子进程终止

子进程都死光了

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <errno.h>
int main(){
	pid_t pid1;
	if((pid1=fork())<0)
	    perror("fork");
	if(pid1==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n",getppid());
		_exit(0);
	}
	pid_t pid2;
	if((pid2=fork())<0)
	    perror("fork");
	if(pid2==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n",getppid());
		_exit(0);
	}
	printf("这是父进程，pid=%d\n",getpid());
//非阻塞模式等待并回收所有子进程，等待的同时做空闲处理。
	while(1){
		pid_t pid=waitpid(-1,NULL,WNOHANG);
		if(pid==-1){
//errno==ECHILD表示已没有可回收的子进程了
			if(errno!=ECHILD){
				perror("wait");
				exit(EXIT_FAILURE);
			}
			printf("子进程都死光了\n");
			break;
		}
		if(pid)
//成功回收该子进程
		    printf("%d子进程终止\n",pid);
		else 
//所等子进程仍在运行，此时父进程出现空闲时间，可在这里进行空闲处理
		    printf("在这里进行空闲处理");
	}
	return 0;
}


回收特定子进程

无论一个进程是正常终止还是异常终止，都会通过系统内核向其父进程发送SIGCHILD（17）信号，父进程可以忽略该信号，也可以提供一个针对该信号的信号处理函数，在信号处理函数中以异步的方式回收该子进程。这样不仅流程简单，而且僵尸的存活时间短，回收效率高。
//08.c
输出：
这是父进程，pid=5979
这是子进程，pid=5980,父进程的pid=5979

5980子进程终止5979父进程终止

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <errno.h>
int main(){
	pid_t pid;
	if((pid=fork())<0)
	    perror("fork");
	if(pid==0){
		printf("这是子进程，pid=%d,",getpid());
		printf("父进程的pid=%d\n",getppid());
		_exit(0);
	}
	else
		printf("这是父进程，pid=%d\n",getpid());
	//等待并回收所有子进程，忽略其终止状态。
		pid=waitpid(pid,NULL,0);
		if(pid==-1){
			if(errno!=ECHILD){
				perror("wait");
				exit(EXIT_FAILURE);
			}
		}
		else
			printf("%d子进程终止",pid);
		printf("%d父进程终止\n",getpid());
	return 0;
}

7）创建新进程的exec函数族
与fork或vfork函数不同，exec函数不是创建调用进程的子进程，而是创建一个新的进程取代调用进程自身。新进程会用自己的全部地址空间，覆盖调用进程的地址空间，但进程的PID保持不变。
<unistd.h>
extern char **environ;
int execl(const char *path, const char *arg, ...
                       /* (char  *) NULL */);
int execlp(const char *file, const char *arg, ...
                       /* (char  *) NULL */);
int execle(const char *path, const char *arg, ...
                       /*, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],
                       char *const envp[]);
int execve(const char *filename, char *const argv[],

                  char *const envp[]);


//10execl.c

输出：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
	if(execl("/bin/pwd","pwd",NULL)==-1){
		perror("execl");
		exit(EXIT_FAILURE);
	}
	printf("本函数执行完毕");
	return 0;
}


//10execle.c

输出：

/home/y/case8

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
	char *envp[]={"HOME=/home/y",NULL};
	if(execle("/bin/pwd","pwd",NULL,envp)==-1){
		perror("execl");
		exit(EXIT_FAILURE);
	}
	printf("本函数执行完毕");
	return 0;
}

//10execlp.c

输出：

/home/y/case8

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
	if(execlp("pwd","pwd",NULL)==-1){
		perror("execl");
		exit(EXIT_FAILURE);
	}
	printf("本函数执行完毕");
	return 0;
}

//10vexec.c

输出：

本函数执行完毕
/home/y/case8
3086子进程终止

3085父进程终止

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(){
	pid_t pid=vfork();
	if(pid==-1){
		perror("vfork");
		exit(EXIT_FAILURE);
	}
	if(pid==0){
		if(execl("/bin/pwd","pwd",NULL)==-1){
			perror("execl");
			exit(EXIT_FAILURE);
		}
		_exit(0);
	}
	else
	    printf("本函数执行完毕\n");
	pid=wait(NULL);
	    if(pid==-1 && errno!=ECHILD){
	    	perror("wait");
		exit(EXIT_FAILURE);
	    }
	printf("%d子进程终止\n",pid);
	printf("%d父进程终止\n",getpid());
	return 0;
}

使用system函数可以执行shell命令

//11system.c

输出：

Shell不可用

#include <stdio.h>
#include <stdlib.h>
int main(){
	int status;
	if(status=system(NULL)==-1){
		perror("system");
		exit(EXIT_FAILURE);
	}
	if(!status)
	    printf("Shell不可用\n");
	else{
		if((status=system("ls -l"))==-1){
			perror("system");
			exit(EXIT_FAILURE);
		}
		printf("%d\n",WEXITSTATUS(status));
	}
	return 0;
}



花椒酱不吃花椒喵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现文件锁(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-22 489
C语言实现文件锁(附完整源码)
C语言文件锁
qq_35527370的博客
09-03 1065
F_SETLKW :设置文件锁。函数功能： 设置文件锁。fd ： 文件描述符。
C语言提供的线程/进程间同步（锁）机制
海棠花的博客
12-31 6335
##C语言提供的线程间同步（锁）机制 /usr/include/pthread.h中提供 1、互斥体 （Mutex） 描述：互斥体是比信号量更为简单是睡眠锁。 使用范围：最为常用 /* Initialize a mutex. */ extern int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) __THROW __nonnull...
[C++] 使用flock构建文件锁，进程读写锁
CoderUnion的博客
09-10 1044
C语言文件锁函数flock以及利用其构建一个简单的进程互斥锁
【C/C++ 文件操作】深入理解C语言中的文件锁定机制
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
09-17 738
在多线程编程中，文件操作的线程安全性是一个不可忽视的问题。C语言的标准输入输出库（Standard Input/Output Library，简称 stdio）提供了一系列函数来实现这一目标。本文将深入探讨这些函数及其工作原理。
我们在 Linux 环境中用 C 编程时，如果对文件读写，Linux 会自动给文件加锁嘛？以及怎么加文件锁？
最新发布
shimly123456的博客
10-24 318
这个程序里没有给文件加锁，我同时运行了 8 个这样的程序，最后的 result file 里的数字是 127，而非 800，说明 Linux 本身并不会给文件加锁。上面这个程序会读取文件中的数字，然后给数字+1，再写回文件。先说结论，结论是不会。我写了一个这样的程序。
linux基础学习+进程+信号+线程+线程锁+进程锁+信号量+网络socket套接字编程
05-04
①Linux基础学习：文件类命令、压缩命令、进程命令、服务器搭建、用户管理、vim学习、gcc/g++编译、linux静态库/动态库、gdb学习、makefile基础学习、C语言文件操作类函数、C语言目录操作函数等； ②linux系统编程...
Python使用文件锁实现进程间同步功能【基于fcntl模块】
01-21
本文实例讲述了Python使用文件锁实现进程间同步功能。分享给大家供大家参考，具体如下： 简介 在实际应用中，会出现这种应用场景：希望shell下执行的脚本对某些竞争资源提供保护，避免出现冲突。本文将通过fcntl模块...
shell脚本实现文件锁功能
09-15
文件锁是多进程环境下控制资源访问的一种机制。在Linux系统中，当多个进程可能同时尝试修改同一份数据时，为了避免冲突和数据损坏，就需要使用文件锁来协调。这里我们关注的是使用`flock`命令在Shell脚本中实现这一...
详解Linux文件锁flock
09-15
Linux文件锁`flock`是进程间同步的一种机制，它用于在多个进程访问同一文件时保护数据的完整性。在多进程环境下，如果没有适当的同步措施，同时读写同一文件可能导致数据混乱。`flock`提供了这样的保护，但它不同于...
linux shell之文件锁
09-15
在Linux环境中，尤其是在编写shell脚本时，有时我们需要确保同一时间只有一个进程在执行特定的任务，这就是文件锁的作用。文件锁是一种简单的同步机制，用于避免多个进程同时访问同一资源，从而防止数据的不一致性和...
C语言文件锁的实现
xixixixixixixi21的博客
07-30 3427
c语言文件锁的实现
c++ 进程锁
weixin_34101229的博客
12-26 2884
2019独角兽企业重金招聘Python工程师标准>>> ...
linux lockf文件锁存在,进程停止,linux文件锁
weixin_39564617的博客
05-10 438
本文中不涉及线程的文件锁，想了解可以参考pthread 的man手册。建议锁、强制锁、记录锁建议锁如果某一个进程对一个文件持有一把锁之后，其他进程仍然可以直接对文件进行操作(open, read, write)而不会被系统禁止，即使这个进程没有持有锁。只是一种编程上的约定。建议锁只对遵守建议锁准则的进程生效(程序在操作前应该自觉的检查所的状态之后才能进行后续操作)。强制锁试图实现一套内核级的锁操作...
fcntl函数的用法总结
热门推荐
rotation博客
07-21 4万+
fcntl函数功能 记录锁
c语言 文件锁,C语言文件与目录（五）文件锁
weixin_39878698的博客
05-20 1018
1)文件锁定所谓的文件锁定，指的是以独占的方式打开文件。一个程序打开文件以后，其它的程序不能读取或写入文件。文件锁定有利于文件内容的一致性。本节将讲解文件的锁定权限问题。 文件锁定的理解:当多个程序程序同一个文件时，可能导致文件的内容不一致情况。例如一个文件中的数据是一个账户金额。用户打开这个文件读取数据，进行处理以后将写结果写入到文件。如果文件没有进行锁定时，可以发生下面这种错误。(1)假设置文...
c语言文件锁Windows,6.9.3 文件锁操作
weixin_39645003的博客
05-18 612
6.9.3 文件锁操作在锁机制的使用中，最常见的操作有锁的请求、释放和测试等，这些操作代码基本类似，本处将一一说明。1. 测试锁设计函数SeeLock，它查询文件描述符fd对应文件的锁信息，其原型为：void SeeLock(int fd, int start, int len);本函数查询描述符fd对应文件从偏移start处开始的len字节中的锁信息，如代码6-5所示：代码6-5 测试锁源码(节...
c++ 进程锁：在进程间使用Windows的互斥锁Mutex
欧特GO
11-10 5539
说明：当多个进程对计算机上的同一份文件进行操作时候，需要对文件进行保护，防止多个进程同时对文件进行修改造成错误，因此可采用Windows的互斥锁Mutex来进行加锁。 // CreatMutex.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <stdio.h> #include <windows.h> #include <iostream> using namespace std; int main()
c语言windows多进程文件通信
05-16
在Windows操作系统中，使用C语言实现多进程之间的文件通信是一种常见的需求。...总之，C语言可以很方便地实现Windows多进程文件通信，需要结合文件锁和共享内存等实现机制，以确保进程间的数据安全和同步。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值