Linux应用程序开(day14) ──系统调用与标准IO、文件描述符、命名管道

最新推荐文章于 2022-10-01 22:41:20 发布
最新推荐文章于 2022-10-01 22:41:20 发布
阅读量733 收藏
点赞数 3
分类专栏： Linux应用程序开发学习笔记 文章标签： linux 多线程 c语言 gcc/gdb编译调试 实时操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41835640/article/details/105262922
版权

目录：

内容：

  • 系统调用与标准IO
  • 文件描述符

系统调用：

open函数

int open(const char *pathname, int flags);
或
int open(const char *pathname,int flags, mode_t mode);

作用：打开文件
参数：
    pathname:文件路径
    flags:以什么方式打开
    mode:若需要创建文件，则文件的权限是什么
返回值：失败返回-1，成功返回文件描述符
flags取值：

取值含义
O_RDONLY以只读的方式打开
O_WRONLY以只写的方式打开
O_RDWR以可读、可写的方式打开
O_CREAT文件不存在则创建文件，使用此选项时需使用mode说明文件的权限
O_EXCL如果同时指定了O_CREAT，且文件已经存在，则出错
O_TRUNC如果文件存在，且为只读或只写的方式打开，则清空文件内容
O_APPEND写文件时，数据添加到文件末尾
O_NONBLOCK当打开的文件是FIFO、字符文件、块文件时，此选项为阻塞标志位

示例：

fd1 = open("test0402",O_CREAT|O_WRONLY,0777);

fd_src = open(argv[1],O_RDONLY);

close函数

int close(int fd);

作用：关闭文件
参数：文件描述符
返回值：成功返回0，失败返回-1

示例：

close(fd_src);

write函数

ssize_t write(int fd, const void *addr,size_t count);

作用：把数据写到文件
参数：
    fd：文件描述符
    addr：要写入的数据的内存首地址
    conte：写入的字节个数
返回值：成功返回实际写入的字符个数，失败返回-1

示例：

write(fd_dest,buf,ret);

read函数

ssize_t read(int fd, void *addr, size_t count);

作用：把数据从文件读出
参数：
    fd：文件描述符
    addr：准备存放数据的内存首地址
    conte：读入的字节个数
返回值：成功返回实际读入的字符个数，失败返回-1

示例：

ret = read(fd_src,buf,sizeof(buf));

标准IO：

fopen函数

FILE* fopen(const char *pathname,const char *mode);

作用：打开文件
参数：
    pathname:文件路径
    mode:流的打开方式
返回值：成功返回指向改流的指针，失败返回NULL
mode取值：

模式功能
r或rb以只读方式打开一个文本文件（不创建文件）
w或wb以写方式打开文件（使文件长度截断为0字节，创建一个文件）
a或ab以添加方式打开文件，即在末尾添加内容，当文件不存在时，创建文件用于写
r+或rb+以可读、可写的方式打开文件(不创建新文件)
w+或wb+以可读、可写的方式打开文件（使文件长度为0字节，创建一个文件）
a+或ab+以添加方式打开文件，打开文件并在末尾更改文件（如果文件不存在，则创建文件）

示例：

	fp_src = fopen(filename,"w");

fclose函数

int fclose(FILE *stream);

作用：关闭文件
参数：文件描述符
返回值：成功返回0，失败返回EOF

示例：

	fclose(fp_src);

fwrite函数

size_t fwrite(const void *ptr, size_t size,size_t nobj, FILE *stream);

作用：把数据写到文件
参数：
    ptr：要写入的数据
    size：要写入的数据的大小
    nobj：写入的数据块的个数
    stream：要操作的数据流
返回值：成功返回实际写入的字符个数

示例：

		fwrite("    ",4,1,fp_src);

fread函数

size_t fread(void *ptr, size_t size,size_t nobj, FILE *stream);

作用：把数据从文件读出
参数：
    ptr：要存放数据的首地址
    size：要读入的数据的大小
    nobj：读出的数据块的个数
    stream：要操作的数据流
返回值：成功返回实际读出的字符个数

示例：

ret = fread(arg,10,1,fp_src);

文件描述符：

描述

    在Linux中万事万物皆是文件，而想要访问文件，就需要用到文件描述符。每个进程都有一张文件描述符的表，其中0 1 2 分别是标准输入、标准输出、标准错误。在进程中打开其他文件的时候，系统会返回文件描述符表中最小可用的文件描述符表，然后进行记录。这里有两个复制文件描述符的函数，分别是dup()和dup2()，下面我们进行介绍；

dup函数

int dup(int oldfd);

作用：拷贝一个文件描述符
参数：旧的文件描述符
返回值：成功返回新的文件描述符，失败返回-1
注意：新的文件描述符和旧的文件描述符指向同一个文件，共享旧文件描述符所有的锁定、读写位置、权限。
示例代码：

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

void main(){

	int fd1,fd2;
	char buf[] = "helloworld";
	char buf1[] = "hi everyone";

	fd2 = dup(1);
	printf("fd2 is %d\n",fd2);
	write(1,buf,sizeof(buf));
	write(fd2,buf,sizeof(buf1));
	
	fd1 = open("test0402",O_CREAT|O_RDWR,0777);
	printf("fd1 is %d\n",fd1);
	if(fd1<0)
	{
		perror("fd1 error \n");
		exit(-1);
	}

	close(1);
	dup(fd1);
	printf("glq20200402\n");

	close(1);
	dup(fd2);
	printf("abcdefgh\n");
}

我们对其文件描述符的变化过程进行分析（下图中的“=”指变化过程，例如“3=1”指3复制成了1）：
在这里插入图片描述

dup2函数

int dup2(int oldfd, int newfd);

作用：拷贝一个文件描述符
参数：旧的文件描述符，新的文件描述符
返回值：成功返回新的文件描述符，失败返回-1
注意：如果新的文件描述符已经被使用，则会先关闭，再复制。
实例代码（文件描述符代码在注释）：

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

int main(int argc, char *argv[])
{
	int fd1;
	int fd2 = 3;
	int err = 0;
								//默认打开 0 1 2
	err = dup2(1,fd2); //将3 复制成1 同时返回3 || 0 1 2 3=1
	if(err<0)
	{
		perror("dup2");
	}
	printf("fd2=%d,err=%d\n", fd2, err);//fd2=3,err=3
	fd1 = open("test", O_CREAT|O_RDWR, S_IRWXU);//生成了一个新的4 || 0 1 2 3->1 4(fd1)
	dup2(fd1,1);//1复制成4(fd1) 0 1->4 2 3=1 4(fd1)
	printf("hello world\n");//1->4(test文件) 所以写到文件内
	dup2(fd2,1);//1->fd2(3)->1 || 0 1->4->1 2 3->1 4(fd1)
	printf("I love you \n");//此时1是标准输出，所以输出到屏幕
	return 0;

命名管道(FIFO):

描述：

  命名管道和管道（pipe）类似，都是用来实现不同进程之间通信的，但是FIFO是以文件形式存放在文件系统的，可以通过ls命令实实在在的查看到。FIFO文件存放在文件系用中，但是内容存放在内存中。pipe只能是有子父关系的进程才可以通信，但是FIFO不是，任何进程之间都可以进行通信。FIFO是有名字的，不同的进程通过管道的名字进行通信，FIFO的缓冲区大小为4KB。它和pipe一样，传送的数据是无格式的，一但被读取就会自动释放。

FIFO的创建

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

依赖的头文件：

#include <sys/types.h>
#include <sys/stat.h>

参数：
  pathname：FIFO的路径
  mode：以何种方式打开
返回值：成功返回0，失败返回-1

FIFO的读写

  因为FIFO也是文件的一种，所以IO函数都可以作用于FIFO。 下面我们讨论几种情况：

情况一：不指定O_NONBOLCK时只读和只写open的情况

以只读的方式打开：若系统中没有以写方式打开的进程，则该打开一直阻塞等待，直到其他进程以写的方式打开的时候，该只读才会继续执行、正常打开文件。
以只写方式打开：若系统中没有以读方式打开的进程，则该打开一直阻塞等待，直到其他进程以读的方式打开的时候，该只写才会继续执行、正常打开文件。
注意：这里只是讨论的打开的情况还不涉及下面的操作，即代码中的 open(“my_fifo”, O_WRONLY); 这一句。
下面我们用图片进行详解。先执行read和先执行write出现的现象一样，我们以先执行read为例。首先先附上代码：
write文件：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
	int fd;
	int ret;
	char send[100] = "Hello I love you";
	
	ret = mkfifo("my_fifo", S_IRUSR|S_IWUSR);
	if(ret != 0)
	{
		perror("mkfifo");
	}
	printf("before open\n");
	fd = open("my_fifo", O_WRONLY);
	if(fd<0)
	{
		perror("open fifo");
	}
	printf("after open and before read\n");
	write(fd, send, strlen(send));
	printf("write to my_fifo buf=%s\n",send);
	return 0;
}

read文件：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
	int fd;
	int ret;
	char recv[100];
	
	ret = mkfifo("my_fifo", S_IRUSR|S_IWUSR);
	if(ret != 0)
	{
		perror("mkfifo");
	}
	printf("before open\n");
	fd = open("my_fifo", O_RDONLY);
	if(fd<0)
	{
		perror("open fifo");
	}
	printf("after open and before read\n");
	bzero(recv, sizeof(recv));
	read(fd, recv, sizeof(recv));
	printf("read from my_fifo buf=[%s]\n",recv);
	return 0;
}

首先我们先运行read,运行结果如t图1所示，此时只输出了“before open”，并没有输出“after open and before read”，所以程序阻塞在了“ fd = open(“my_fifo”, O_RDONLY);”这一句，原因是此时没有以写的方式打开的进程。
在这里插入图片描述
然后我们运行write,运行了此程序以后，系统中就有了以写方式打开的进程，read就会继续运行，并且获取到管道的内容进行输出。运行结果如图二所示：
在这里插入图片描述

情况二：不指定O_NONBOLCK时read的情况
小情况1：FIFO没有数据时read()会进入阻塞

当FIIFO中没有数据，read会进入阻塞状态，这里我们进行实验，为了保证两个程序都能运行，我们这里先打开write程序，然后打开read程序，二者以只读或者只写的方式打开，然后再write中我们先不发送数据，人为的延迟10秒，这时我们会看到read程序进入阻塞装态，十秒延迟以后就变成运行态的。write的代码如下，read的代码不变。

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


void main()
{
        int fd,ret;
        ret = mkfifo("my_fifo", S_IRUSR|S_IWUSR);
        if(ret != 0)
        {
                perror("mkfifo err\n");
        }
        printf("打开写文件之前\n");
        fd = open("my_fifo",O_WRONLY);
        if(fd<0)
        {
                perror("open error \n");
        }

        printf("打开写文件之后,进入10秒延迟\n");
        sleep(10);
        char send[100] = "helloworld";
        write(fd,send,sizeof(send));

}

运行结果：
在这里插入图片描述

小情况2：write程序退出以后read()变为执行

通信过程中若写进程先退出了，此时read()不阻塞，但是若写进程又重新执行，那么read又会阻塞。
实验的代码如下：
write

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
	int fd;
	char send[100] = "Hello I love you";
	
	fd = open("my_fifo", O_WRONLY);
	if(fd<0)
	{
		perror("open fifo");
	}
	write(fd, send, strlen(send));
	printf("write to my_fifo buf=%s\n",send);
	while(1);
	return 0;
}

read:

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
	int fd;
	int ret;
	
	ret = unlink("my_fifo");	//删除上次运行后残留的fifo
	if(ret<0)
	{
		perror("unlink fifo");
	}
	ret = mkfifo("my_fifo", S_IRUSR|S_IWUSR);
	if(ret != 0)
	{
		perror("mkfifo");
	}
	fd = open("my_fifo", O_RDONLY);
	if(fd<0)
	{
		perror("open fifo");
	}
	while(1)
	{
		char recv[100];
		
		bzero(recv, sizeof(recv));
		read(fd, recv, sizeof(recv));
		printf("read from my_fifo buf=[%s]\n",recv);
		sleep(1);
	}
	return 0;
}

1.首先我们将两个程序都跑起来，可以看到read中第一次可以正确读取，但是读取之后FIFO变为空，read()就会变为阻塞状态。
在这里插入图片描述
2.然后将write程序关闭，此时read()变为执行状态，但是或取得数据为空。
在这里插入图片描述
3.再将write程序启动，正确读取一次以后又会变成阻塞状态。
在这里插入图片描述

情况三:指定O_NONBLOCK

1.先以只读方式打开，若没有其他进程为写而打开，则打开成功且不阻塞
2.先以只写方式打开，若没有其他进程为读而打开，则打开失败，返回-1，说明我们要先打开读方式，再打开写方式。
3.read()，write()方法运行时都不阻塞。
write：

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h> 
#include <stdlib.h>
void main()
{
	int fd,isTrue;
	char arg []="helliworld";
	isTrue = mkfifo("my_fifo",0777);
	if(isTrue != 0){
		perror("管道创建失败\n");
	}

	fd = open("my_fifo",O_WRONLY|O_NONBLOCK);
	if(fd < 0)  
	{  
		perror("open fifo\n");
	        exit(-1);
	}
	write(fd,arg,sizeof(arg));
	printf("发送成功\n");
	while(1);
	
}

read:

#include <stdio.h>  
#include <string.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <fcntl.h> 
#include <stdlib.h>
void main()
{
	int fd,isTrue;
	char arg [100];
	isTrue = mkfifo("my_fifo",0777);
	if(isTrue != 0){
		perror("管道创建失败\n");
	}

	fd = open("my_fifo",O_RDONLY|O_NONBLOCK);
	if(fd < 0)  
	{  
		perror("open fifo\n");
	        exit(-1);
	}

	while(1)
	{
		read(fd,arg,sizeof(arg));
		printf("获取到的内容[%s]\n",arg);
		sleep(1);
	}
}

我们先运行read,再运行write，运行结果如下，可以看到没发送数据的时候read()也不会进行阻塞，只不过读到的数据是空。
在这里插入图片描述

作业

1.调用pipe()函数，实现从子进程发送“hello world”到父进程，父进程打印输出的功能。
解析：只需要创建pipe管道，然后创建一个子进程，在子进程中向管道写，父进程中从管道读

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

void main()
{
	int filedes[2];
	pid_t pid;
	char buff2[20],buff1[]="helloworld";
	if(pipe(filedes)<0){
		perror("pipe error\n");
		exit(-1);
	}	

	pid = fork();

	if(pid<0)
	{
		perror("fork error \n");
		exit(-1);
	}

	if(pid == 0)
	{
		printf("子进程向管道写入数据\n");
		write(filedes[1],buff1,strlen(buff1));

	}else{
		wait(NULL);
		memset(buff2,0,sizeof(buff2));
		read(filedes[0],buff2,sizeof(buff2));
		printf("父进程读出数据[%s]\n",buff2);
	}

}

2.调用dup()函数，通过printf()函数将字符串“hello world”写入到指定文本文件。
解析：文件描述符表中默认的0 1 2 都是打开的，此时我们打开文件文件，就会生成文件描述符3，此时再把1关掉，表中就剩余0 2 3 ，再通过dup()，返回一个最小的即 1 ，就把1重定向到了3即文件。

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

void main()
{
	int fd;
	fd=open("test",O_CREAT|O_RDWR,0777);
	if(fd<0){
		perror("open error \n");
		exit(-1);
	}
	close(1);
	dup(fd);
	printf("hello world\n");


}

3.通过命名管道，以非阻塞的方式，实现两个进程间收发字符串“hello world”的功能。
解析：只需要指定O_NONBLOCK打开，然后read中读取数据，write中写“hellowoord”就可以了。程序见上面【指定O_NONBLOCK】部分。

谢谢大家的观看,如有错误请指正，谢谢！CSDN记录成长！

林宪宇
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux高级运维： 块存储应用案例 、 分布式文件系统和对象存储 （CLUSTER—-DAY43）
01-07
1）分布式文件系统(Distributed File System)是指文件系统管理的物理存储资源不一定直接连接在本地节点上,而是通过计算机网络与节点项链 2）CephFS 使用 Ceph 集群提供与 POSIX 兼容的文件系统 3）允许 Linux 直接将...
进程间通信（匿名管道和命名管道）
_Y__X_的博客
04-09 578
1.进程间通信目的 2.进程间通信分类 3. 管道 4.匿名管道 4.1用fork来共享管道原理 4.2管道创建过程 4.3站在文件描述符角度-深度理解管道 4.3.1如果写端，不关闭文件描述符，且长时间不写入，那么读端可能(管道内有历史数据就会先读取完)长时间阻塞 4.3.2当我们在实际写入时，如果写入条件不满足(包括缓冲区写完)，那么写入端就要被阻塞。 4.3.3如果写入端关闭文件描述符，读取端就会读取到文件末尾，read返回0值 4.3.4如果读取端关闭，写入端进程被OS直接杀掉(OS系统统筹管理资源
linux重定向匹配符文件夹,Linux教程之文件描述符、重定向、管道符、tee命令
weixin_34697150的博客
04-29 162
本节讨论一下几个问题：1. 文件描述符。2. 重定向。3. 管道符4. tee的用法。1. 文件描述符。在Linux系统中一切皆文件。文件夹和设备都是文件。如何用来区别不同的文件呢？这里的区别不是我们在Windows下看到的后缀名不同来区别。也不是我们在Linux下用ls 命令看到的不同文件的列表。这里的文件描述符主要讨论的是对文件操作的一个标识符。无操作就无标识符。比如两个进程同时在对同一个文...
Linux文件操作的相关函数 C语言
ljl113的博客
10-01 1468
c语言文件操作相关函数整理
操作系统 实验四：使用命名管道实现进程通信
weixin_43871692的博客
05-20 996
*实验四：使用命名管道实现进程通信* 1 实验目的 （1）了解windows系统环境下的进程通讯机制。 （2）熟悉Windows系统提供的进程通信API。 2 实验准备知识：相关API函数介绍 1.建立命名管道 函数CreateNamePipe（）创建一个命名管道实例，并返回该管道的句柄。 原型： HANDLE CreateNamePipe（ LPCTSTR lpName， //命名管道的名字 DWORD dwOpenMode， //命名管道的访问模式 DWORD dwP
用命名管道实现两个进程间通信
sing_Hwang的博客
12-21 3262
首先说明一下匿名管道和命名管道之间的区别 匿名管道根据其名字就可以理解到这个管道是隐藏在深海当中不可间的，使用我们进程间要是没有点练习连这条管道都找不到。 但是如果我们嗯是想在两个不相关的文件当中通信的话，凭自己的理解来说我们无法找到这个管道，不相关文件就无法通信。 所以我们需要使用一种特殊的管道，他的名字就是命名管道。 创建命名管道的方法 通过命令创建命名管道的文件 $...
day14：time模块、异常处理、装饰器、主程序调用
12-22
time.strtime 时间格式化6、time.strptime 结构化时间7、time.sleep 休眠二、异常处理三、装饰器1、装饰器：2、当被装饰的函数带参数时3、当装饰器需要有参数时四、主程序调用五、面试题 一、time模块 import time...
Linux操作系统day01.pdf
03-28
Linux操作系统day01.pdf Linux操作系统是当今最流行的操作系统之一，本章节主要介绍Linux操作系统的基本概念和命令操作。 1. Linux字符界面 Linux操作系统提供了两种基本的用户界面：字符界面和图形界面。字符...
嵌入式实习-day4-结构体、文件IO与进程
11-20
今天主要资源内容 1、结构体 ...作业：1、使用文件IO，实现文件的拷贝 2、分析程序运行结果，并写明原因 int main() { printf("hello world"); int i; for(i = 0; i ; i++) { fork(); } }
Linux下通过gettimeofday函数获取程序段执行时间【推荐】
01-20
在Linux下计算某个程序段执行的时间一般使用gettimeofday函数，此函数的声明在sys/time.h文件中。此函数接收两个结构体参数，分别为timeval、timezone.  两个结构体的声明如下： struct timeval { time_t tv_sec;...
子进程通过管道将字符串传给父进程
12-03
子进程通过管道将字符串“hello!\n”传给父进程并显示*/
命名管道非阻塞模式通信
Summer_Xin的博客
06-04 738
名命管道非阻塞模式通信 分析： 代码： //读端 #include <stdio.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <fcntl.h> #define FIFO "/root
进程间通信 - 命名管道实现
weixin_33966095的博客
01-02 432
引子 好，到这里呢，就需要介绍实现进程间通信的第四种方式了， 也就是通过命名管道来实现，前面介绍的那三种方式呢，都是有缺陷或者说局限性太强， 而这里介绍的命名管道相对来说，在这方面就做得好很多了， 比如，剪贴板的话只能实现本机上进程之间的通信， 而邮槽的话虽然是可以实现跨网络之间的进程的通信， 但麻烦的是邮槽的服务端只能接收数据，邮槽的客户端只能发送数据，太悲剧了， 而对于匿名管道的...
管道实现进程间通信之命名管道
xbhinsterest11的博客
06-27 875
管道通信之命名管道
【操作系统】进程间通信（C#）
爱.NET
12-05 489
08年9月入学，12年7月毕业，结束了我在软件学院愉快丰富的大学生活。此系列是对四年专业课程学习的回顾，索引参见：http://blog.csdn.net/xiaowei_cqu/article/details/7747205 进程间通信 命名管道 进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在...
学习进程控制与进程通信_用命名管道来实现两个进程间的通信
mqmine的专栏
06-29 767
学习进程控制与进程通信用命名管道来实现两个进程间的通信：  进程A通过管道发送一个“list”字符串给进程B；进程B收到进程A发送过来的“list”命令后，读取当前目录下的所有普通文件把文件名显示到屏幕；  进程A通过管道发送一个“end”字符串给进程B；  进程B收到进程A发送过来的“end”命令后，结束自己的运行。#include#include#include#include#inc
以命名管道方式实现网络进程间通信的一个实例
Johnny的专栏
07-22 1897
 Win32位API集支持的命名管道(named pipe)是实现网络进程间通信的一种有效手段。命名管道的接口比较简单,在程序中实现比较方便,由其开发的应用程序也很容易使用,只要知道机器及管道的名称即可连接两台机器上的两个进程。命名管道首先由一进程调用CreateNamedPipe函数创建,这一创建命名管道的进程称为Server进程,然后Server进程通过调用ConnectNamedPi
php 进程通信系列 （一） 命名管道
专注于php高级知识分享
07-23 434
数据传输一个进程需要将它的数据发送给另一个进程。通知事件一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。资源共享多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。进程控制有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有状态信息进程不是孤立的，一个足够大的项目绝对不是单一的进程可以支撑的起的。...
使用命名管道的OVERLAPPED方式实现非阻塞模式编程
热门推荐
jiangdf的专栏
06-20 1万+
命令管道是进程间通讯的一种常用方式，对于命令管道的介绍可以参考别的资料和书籍，这里推荐一个《VC++下命名管道编程的原理及实现》这篇博文，写得比较清楚。但是都是介绍了阻塞模式的编程，我这里主要是介绍利用命令管道OVERLAPPED方式使用非阻塞模式编程。注：文中使用的方法就是函数的意思。 参考MSDN,服务器端创建命令管道(使用CreateNamedPipe方法），不使用FILE_FLAG_OV
day4VI和RPM包详细笔记文档
最新发布
07-17
通过学习和实践这些内容，用户可以提升在Linux系统中高效处理文本文件的能力，并理解如何利用RPM包管理器（虽然这部分在给出的信息中并未详细讲述，但通常与软件安装、更新和管理有关）。 这篇笔记文档为初学者提供...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值