UNIX Environmental programming Week1.Day4

系统调用(系统API)

​ 就是操作系统提供的一些功能供程序员使用,这些系统调用已经被封装成了C函数的形式,但它们不是标准C

的一部分

​ 一般应用程序运行在用户态[0,3g),使用系统调用时进入内核态进行系统调用(3,4g) 常用的标准库函数大部分都

在用户态,底层偶尔也会调用系统,但是少部分在内核态例如malloc

​ 系统调用的代码时内核的一部分,其外部接口以共享库函数的形式提供(linux-gate.so\ld-linux.so),并且这些

接口的实现利用软中断进入到内核执行其真正的系统调用代码。

time ./a.out	测试程序运行时间
real	0m0.004s	总运行时间
user	0m0.000s	用户态的执行时间
sys		0m0.000s	内核态的执行时间
发现总时间不一样,消耗在两状态切换浪费时间,输入输出浪费时间,CPU很忙没及时处理
    总运行时间 = 用户态时间+内核态时间+切换时间+IO时间+CPU时间

一切皆文件

​ UNIX/Linux操作系统把设备和服务都抽象成了文件形式,并提供了一套简单而统一的接口,这部分接口就是文件IO,

也就是说UNIX/Linux系统中任何对象都可以当做某种特殊的文件,以文件的形式访问

Linux文件的分类

​ 普通文件 - 包括纯文本文件,二进制文件,压缩文件

​ 目录文件 d(direction)

​ 块设备文件 b(block) 保存大块数据的设备

​ 字符设备文件 c(char) 类似键盘,鼠标

​ 管道文件 p(pipeline)

​ 链接文件 l(link)

​ Socket文件 S 通常用于网络数据连接

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

	int open(const char *pathname, int flags);
	功能:打开文件
    pathname:文件路径	
    flags:文件打开方式
        O_RDONLY 读 
        O_WRONLY 写 
        O_RDWR 读写
    	O_CREAT 文件不存在创建	
        O_EXCL 如果文件存在创建失败 
        O_NOCTTY 非阻塞 
        O_TRUNC 文件存在清空打开
    	O_APPEND 追加 
        O_SYNC 同步,写入数据等待数据被写入 
        O_ASYNC 异步,当文件进行读写时,向进程发送型号SIGIO
    返回值:文件描述符,类型基于标准库FILE*,代表了一个打开的文件
	int open(const char *pathname, int flags, mode_t mode);
	功能:创建文件
    flags:
              S_IRWXU  00700 user (file owner) has read, write and execute permission
              S_IRUSR  00400 user has read permission
              S_IWUSR  00200 user has write permission
              S_IXUSR  00100 user has execute permission
              S_IRWXG  00070 group has read, write and execute permission
              S_IRGRP  00040 group has read permission
              S_IWGRP  00020 group has write permission
              S_IXGRP  00010 group has execute permission
              S_IRWXO  00007 others have read, write and execute permission
              S_IROTH  00004 others have read permission
              S_IWOTH  00002 others have write permission
              S_IXOTH  00001 others have execute permission
        	  rw-r--r-- 0644
    返回值:成功非0,失败-1
	int creat(const char *pathname, mode_t mode);

练习:测试fopen的打开方式与open的哪些参数相对应(strace ./a.out 追踪文件查看信息)

​ w: O_WRONLY|O_CREAT|O_TRUNC, 0666

​ w+: O_RDWR|O_CREAT|O_TRUNC, 0666

​ r: O_RDONLY

​ r+: O_RDWR

​ a: O_WRONLY|O_CREAT|O_APPEND, 0666

​ a+: O_RDWR|O_CREAT|O_APPEND, 0666

	#include <unistd.h>
	ssize_t write(int fd, const void *buf, size_t count);
	功能:把内存中的数据写入到文件中
    fd:文件描述符,也就是open的返回值
    *buf:待写入的内存数据的首地址
    count:要写入的字节数
    返回值:返回实际写入的字节数
	ssize_t read(int fd, void *buf, size_t count);
	功能:从文件中读取数据到内存
    fd:文件描述符,也就是open的返回值
    *buf:存储数据的首地址
    count:要读取的字节数
	返回值:实际读取到的字节数
    int close(int fd);
	功能:关闭文件

练习2:分别使用标准IO(fopen/fread/fwrite)和系统IO写入100w个整数 到文件中 测试谁更快

标准IO:fwrite
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real	 0m0.024s
user	0m0.012s
sys	   0m0.004s

系统IO:write
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real	 0m0.804s
user	0m0.004s
sys	  0m0.780s

惊了呀!青出于蓝,使用标准IO比系统IO更快,原因就是标准IO有缓冲区机制在!!!,在写入数据时

不会直接使用系统IO,而是利用缓冲区进行存储,等到缓冲区填满后再调用系统IO!所以大大降低了写入的次数

导致时间大幅降低,如果给系统IO手动添加一个更大的缓冲区时,它的速度会比IO更快
ubuntu@~/classwork/UNIX/unix day03$ time ./a.out
real	0m0.004s
user	0m0.000s
sys	0m0.000s
这是手动添加8k缓冲区的效果 果然很快

随机读写

​ 每个打开文件都有一个记录读写位置的指针,也叫文件位置指针,对文件的读写操作都是从该指针向

​ 的位置进行的,并且位置指针会随着读写操作而增加移动。

​ 一个打开的文件,位置指针就会指向头文件开头,如果使用O_APPEND,则会在末尾。

​ 如果想要随机读写文件中任何位置的数据,需要调整文件位置指针

	#include <stdio.h>
	int fseek(FILE *stream, long offset, int whence);
	标准IO
	#include <sys/types.h>
	#include <unistd.h>
	off_t lseek(int fd, off_t offset, int whence);
	系统IO
    fd:文件描述符
    offset:偏移值
    whence:基础位置
     SEEK_SET The offset is set to offset bytes.
     SEEK_CUR The offset is set to its current location plus offset bytes.
     SEEK_END The offset is set to the size of the file plus offset bytes.
     返回值:返回调整后文件位置指针所处的位置
	
     在越过文件末尾继续写入数据,相隔一段位置将形式空洞,空洞也一样会被计算到文件大小中,
     但是不占有磁盘空间

系统IO读写文本文件

​ 由于系统IO是没有办法使用fscanf/fprintf函数的,因此不能直接读写文本文件

​ 写文本文件: 把要写入的对象 通过sprintf 转换为字符串,然后再写入到文件中。

​ 读文本文件:先按照字符串形式先读取到字符串变量中,然后在使用 sscanf 来提取出对应的数据使用

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

typedef struct Student
{
	char name[20];
	char sex;
	short age;
	int sid;
}Student;

int main(int argc,const char* argv[])
{
	/*int fd = open("stu.txt",O_RDWR|O_CREAT,0644);
	if(fd < 0) return -1;
	Student stu = {"Amo",'m',20,1000};
	for(int i=0;i<10;i++)
	{
		stu.sid = 1000+i;
		char str[255] = {};
		sprintf(str,"%s %c %hd %d\n",stu.name,stu.sex,stu.age,stu.sid);
		printf("str:%s\n",str);
		write(fd,str,strlen(str));
	}
	close(fd);
	*/
	int fd = open("stu.txt",O_RDONLY);
	
	if(fd < 0) return -1;
	
	char* buf = malloc(4096);
	char* temp = buf;
	read(fd,buf,4096);
	while(strstr(buf,"\n"))
	{
		Student stu = {};
		sscanf(buf,"%s %c %hd %d\n",stu.name,&stu.sex,&stu.age,&stu.sid);
		printf("str:%s %c %hd %d\n",stu.name,stu.sex,stu.age,stu.sid);
		buf = strstr(buf,"\n")+1;
		
	}
	free(temp);
	close(fd);
	temp = NULL;
	buf = NULL;
}

文件描述符

​ 1、非负整数,代表一个打开的文件

​ 2、由系统调用而返回,可以被内核空间引用

​ 3、它代表着一个内核对象(相当于FILE对象),因为内核不能暴露它的地址,因此不能返回一个对象指针

​ 4、内核中有一张记录所有打开的文件对象,文件描述符就是访问这张表的下标,因此文件描述符也叫做

​ 句柄,也就是访问指针的凭证。

​ 内核中有三个默认打开的文件描述符:

​ 句柄 功能

​ 0 标准输入 stdin

​ 1 标准输出 stdout

​ 2 标准错误 stderr

文件描述符的复制:

	#include <unistd.h>
	int dup(int oldfd);
	功能:复制一个已经打开的文件描述符
    返回值:返回一个当前没有使用过的最小的文件描述符
	int dup2(int oldfd, int newfd);
	功能:复制一个指定的文件描述符
    newfd:想要复制成的文件描述符,如果打开冲突,则会先关闭再复制
    注意:复制成功后,相当于两个文件描述符同时对应一个打开的文件

​ 练习3:使用系统IO来实现一个带覆盖提醒的cp命令

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

int main(int argc,const char* argv[])
{
	if(3 != argc)
	{
		printf("User: ./cp src dest");
		return 0;
	}
	
	int src = open(argv[1],O_RDONLY);
	if(0 > src)
	{
		printf("源文件不存在,请检查\n");
		return 0;
	}

	int dest = open(argv[2],O_WRONLY|O_EXCL|O_CREAT,0644);
	if(0 > dest)
	{
		printf("目标文件已存在,是否覆盖(Y/y)\n");
		char cmd = getchar();
		if('y' != cmd && 'Y' != cmd)
		{
			printf("停止拷贝了!\n");
			close(src);
			return 0;
		}
		else
		{
			printf("覆盖目标文件!\n");
			dest = open(argv[2],O_WRONLY|O_TRUNC);
		}
	}

	int ret = 0;
	char buf[4096] = {};
	while(ret = read(src,buf,sizeof(buf)))
	{
		write(dest,buf,ret);	
	}
	close(src);
	close(dest);
	return 0;
}
上一篇:Week1


下一篇:哈工大计算机网络WEEK1-学习总结