驱动初级Day05_字符设备驱动基础中_IO模型

已于 2022-11-18 19:24:25 修改
阅读量151 收藏 1
点赞数
分类专栏： Liunx 文章标签： arm开发 linux
于 2022-11-18 19:22:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42733748/article/details/127906948
版权

字符设备驱动基础中_IO模型

一、五种IO模型------读写外设数据的方式

  1. 阻塞: 不能操作就睡觉
    在这里插入图片描述

  2. 非阻塞：不能操作就返回错误
    在这里插入图片描述

  3. 多路复用：委托中介监控

在这里插入图片描述

  1. 信号驱动：让内核如果能操作时发信号，在信号处理函数中操作
    在这里插入图片描述

  2. 异步IO：向内核注册操作请求，内核完成操作后发通知信号

在这里插入图片描述

二、阻塞与非阻塞

应用层：

​ open时由O_NONBLOCK指示read、write时是否阻塞

​ open以后可以由fcntl函数来改变是否阻塞：

flags = fcntl(fd,F_GETFL,0);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);

驱动层：通过等待队列

wait_queue_head_t //等待队列头数据类型

init_waitqueue_head(wait_queue_head_t *pwq) //初始化等待队列头
    
wait_event_interruptible(wq,condition)
/*
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
    wq:等待队列头
    condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）
*/
        
wait_event(wq,condition) //深度睡眠

wake_up_interruptible(wait_queue_head_t *pwq)
        
wake_up(wait_queue_head_t *pwq)
    
    
/*
1. 读、写用不同的等待队列头rq、wq
2. 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
3. 写入数据成功时唤醒rq，读出数据成功唤醒wq
*/

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

阻塞

在这里插入图片描述

阻塞

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

三、多路复用

描述符：

  1. 文件描述符：设备文件、管道文件
  2. socket描述符

3.1 应用层：三套接口select、poll、epoll

select：位运算实现 监控的描述符数量有限（32位机1024,64位机2048） 效率差

poll：链表实现，监控的描述符数量不限 效率差

epoll：效率最高，监控的描述符数量不限

select

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/*	功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
		内核将没有准备就绪的文件描述符，从集合中清掉了。
	参数：  nfds			最大文件描述符数 ，加1
			readfds		读文件描述符集合
			writefds		写文件描述符集合
			exceptfds		其他异常的文件描述符集合
			timeout		超时时间（NULL）
	返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
		   当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
*/
void FD_CLR(int fd, fd_set *set);
//功能：将fd 从集合中清除掉

int  FD_ISSET(int fd, fd_set *set);
//功能：判断fd 是否存在于集合中
 
void FD_SET(int fd, fd_set *set);
//功能：将fd 添加到集合中

void FD_ZERO(fd_set *set);
//功能：将集合清零

//使用模型:

while(1)
{
    /*得到最大的描述符maxfd*/
    /*FD_ZERO清空描述符集合*/
	/*将被监控描述符加到相应集合rfds里  FD_SET*/
    /*设置超时*/
    ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);
    if(ret < 0)
    {
        if(errno == EINTR)//错误时信号引起的
        {
        	continue;   
        }
        else
        {
            break;
        }
    }
    else if(ret == 0)
    {//超时
        //.....
    }
    else
    { //> 0 ret为可被操作的描述符个数
        if(FD_ISSET(fd1,&rfds))
        {//读数据
            //....
        }
        if(FD_ISSET(fd2,&rfds))
        {//读数据
            //....
        }
        ///.....
        if(FD_ISSET(fd1,&wfds))
        {//写数据
            //....
        }
    }
}

3.2 驱动层：实现poll函数

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
/*功能：将等待队列头添加至poll_table表中
  参数：struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll
{
    unsigned int mask = 0;
    /*
    	1. 将所有等待队列头加入poll_table表中
    	2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
    	3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
    */
    
    return mask;
}

在这里插入图片描述

app

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3.3 testmychar_select.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>

#include "mychar.h"

int main(int argc, char * argv[])
{
   int fd = -1; 
   char buf[8]="";
   int ret=0;
   fd_set rfds;

   if (argc < 2)
   {
     printf ("The argument is too fewn"); 
     return 1;
   }

   fd = open (argv [1] ,O_RDWR); 
   if(fd < 0)
   {
     printf ("open %s failed\n", argv[1]); 
     return 2;
   }

   while(1)
   {
      FD_ZERO(&rfds);
      FD_SET(fd, &rfds);
      ret = select(fd + 1, &rfds,NULL,NULL,NULL); 
      if(ret < 0)
      {
          if(errno == EINTR)
          {
             continue;
          }
          else
          {
             printf("select error\n");
             break;
          }
      }
      if(FD_ISSET(fd,&rfds))
      {
         read(fd, buf,8);
         printf("buf=%s\n", buf);
      }
   }
 
   close (fd); 
   fd = -1; 
   return 0;

}

四、信号驱动

4.1 应用层：信号注册+fcntl

signal(SIGIO, input_handler); //注册信号处理函数

fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PID

oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);//将该设备的IO模式设置成信号驱动模式

void input_handler(int signum)//应用自己实现的信号处理函数，在此函数中完成读写
{
    //读数据
}

//应用模板
int main()
{
	int fd = open("/dev/xxxx",O_RDONLY);

	fcntl(fd, F_SETOWN, getpid());

	oflags = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, oflags | FASYNC);

	signal(SIGIO,xxxx_handler);

	//......
}
    
void xxxx_handle(int signo)
{//读写数据
    
}

4.2 驱动层：实现fasync函数

/*设备结构中添加如下成员*/
struct fasync_struct *pasync_obj;

/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
{
	struct hello_device *dev = filp->private_data; 
	return fasync_helper(fd, filp, mode, &dev->pasync_obj);
}

/*写函数中有数据可读时向应用层发信号*/
if (dev->pasync_obj)
       kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);
       
/*release函数中释放异步通知结构对象*/
if (dev->pasync_obj) 
	fasync_helper(-1, filp, 0, &dev->pasync_obj);

int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);
/*
	功能：产生或释放异步通知结构对象
	参数：
	返回值：成功为>=0,失败负数
*/

void kill_fasync(struct fasync_struct **, int, int);
/*	
	功能：发信号
	参数：
		struct fasync_struct ** 指向保存异步通知结构地址的指针
		int 	信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
		int 	读写信息POLLIN、POLLOUT
*/

/*
功能：产生或释放异步通知结构对象
参数：
返回值：成功为>=0,失败负数
*/

void kill_fasync(struct fasync_struct *, int, int);
/
功能：发信号
参数：
struct fasync_struct ** 指向保存异步通知结构地址的指针
int 信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
int 读写信息POLLIN、POLLOUT
*/

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

app

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.3 testmychar_signal.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>

#include "mychar.h"

int fd = -1; 

void sigio_handler(int signo);
int main(int argc, char * argv[])
{
   int ret=0;
   int flg=0;
   fd_set rfds;

   if (argc < 2)
   {
     printf ("The argument is too fewn"); 
     return 1;
   }
   
   signal(SIGIO, sigio_handler);

   fd = open (argv [1] ,O_RDWR); 
   if(fd < 0)
   {
     printf ("open %s failed\n", argv[1]); 
     return 2;
   }

   fcntl(fd, F_SETOWN, getpid());
 
   flg = fcntl(fd,F_GETFL); 
   flg |= FASYNC;
   fcntl(fd,F_SETFL,flg);


   while(1)
   {
   }
 
   close (fd); 
   fd = -1; 
   return 0;

}


void sigio_handler(int signo)
{
   char buf[8] = "";
   read(fd, buf,8);
   printf ("buf=%s\n" ,buf);
}

五、mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/poll.h>

#include "mychar.h"

#define BUF_LEN 100

#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num = MYCHAR_DEV_CNT;

struct mychar_dev
{
   struct cdev mydev;
   char mydev_buf[BUF_LEN];
   int  curlen; 
   
   wait_queue_head_t  rq;
   wait_queue_head_t  wq;
  
   struct fasync_struct *pasync_obj;
};

struct mychar_dev gmydev_arr[MYCHAR_DEV_CNT];

int mychar_open(struct inode * pnode, struct file * pfile)
{
	pfile->private_data =container_of(pnode->i_cdev,struct mychar_dev,mydev) ;
	printk("mychar_open is called\n");
	return 0;
}
int mychar_close(struct inode * pnode, struct file * filp)
{
        struct mychar_dev *pmydev=(struct mychar_dev *)filp->private_data;
        if(pmydev->pasync_obj) 
	    fasync_helper(-1, filp, 0, &pmydev->pasync_obj);
	printk("mychar_close is called\n");
	return 0;
}

ssize_t mychar_read(struct file *filp, char __user *puser, size_t count, loff_t *ppos)
{
  struct mychar_dev *pmydev=(struct mychar_dev *)filp->private_data;
  int size=0;
  int ret=0;
  if(pmydev->curlen <= 0)
  {
      if(filp->f_flags & O_NONBLOCK)
      {  //非阻塞
         printk("O_NONBLOCK No Data Read\n") ;
         return -1;
      }
  else
  {//阻塞
      ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
      if(ret)
      {
        printk("Wake up by signal\n");
        return  -ERESTARTSYS;
      }
  }
}

  if(count>pmydev->curlen)
  {
    size=pmydev->curlen;
  }
  else
  {
    size=count;
  }

  ret=copy_to_user(puser,pmydev->mydev_buf,size);
  if(ret)
  {
    printk("copy_to_user failed\n");
    return -1;
  }	
  memcpy(pmydev->mydev_buf,pmydev->mydev_buf+size,pmydev->curlen-size);

  pmydev->curlen-=size;
  wake_up_interruptible(&pmydev->wq);
  return size;
}


ssize_t mychar_write (struct file *filp, const char __user *puser, size_t count, loff_t *ppos)
{

  struct mychar_dev *pmydev=(struct mychar_dev *)filp->private_data;
  int size=0;
  int ret=0;

  if(pmydev->curlen >= BUF_LEN)
  {
      if(filp->f_flags & O_NONBLOCK)
      {
        printk("O_NONBLOCK Can not write data\n");
        return -1;
      }
      else 
      {
        ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
        if(ret)
        {
        printk("wake up by signal\n");
        return -ERESTARTSYS;
        }
      }
  }

  if(count>BUF_LEN-pmydev->curlen)
  {
    size=BUF_LEN-pmydev->curlen;
  }
  else
  {
    size=count;
  }

  ret=copy_from_user(pmydev->mydev_buf+pmydev->curlen,puser,size);
  if(ret)
  {
    printk("copy_from_user failed\n");
    return -1;
  }	

  pmydev->curlen+=size;

  wake_up_interruptible(&pmydev->rq);

  if(pmydev->pasync_obj != NULL)
  {
    kill_fasync(&pmydev->pasync_obj ,SIGIO,POLL_IN);
  }
  return size;
}


long mychar_ioctl (struct file *filp, unsigned int cmd, unsigned long arg)
{
  int __user *pret =(int *)arg;
  int maxlen=BUF_LEN;
  int ret = 0;
  struct mychar_dev *pmydev=(struct mychar_dev *)filp->private_data;

  switch(cmd)
  {
   case MYCHAR_IOCTL_GET_MAXLEN:
     ret = copy_to_user((int *)arg, &maxlen, sizeof(int)); 
     if(ret)
     {
       printk("copy_to_user MAXLEN failed\n");
       return -1;
     }
      break;
   case MYCHAR_IOCTL_GET_CURLEN: 
     ret = copy_to_user(pret, &pmydev->curlen, sizeof(int)); 
     if(ret)
     {
       printk("copy_to_user CURLEN failed\n");
       return -1;
     }
      break;
   default: 
     printk("The cmd is unknown"); 
     return -1;
  }
  return 0;
}

unsigned int mychar_poll(struct file *pfile,poll_table *ptb)
{
   struct mychar_dev * pmydev = (struct mychar_dev * )pfile->private_data;
   unsigned int mask = 0;
   poll_wait(pfile, &pmydev->rq,ptb) ;
   poll_wait(pfile, &pmydev->wq,ptb);
   if(pmydev->curlen > 0)
   {
      mask |= POLLIN | POLLRDNORM;
   }
   if(pmydev->curlen < BUF_LEN)
   {
     mask |= POLLOUT | POLLWRNORM;
   }
   return mask; 
}

int mychar_fasync(int fd,struct file *pfile, int mode)
{
    struct mychar_dev * pmydev = (struct mychar_dev * )pfile->private_data;
    return fasync_helper(fd, pfile , mode , &pmydev->pasync_obj);
}


struct file_operations myops = {
 .owner = THIS_MODULE,
 .open = mychar_open,
 .release = mychar_close,
 .read=mychar_read,
 .write=mychar_write,
 .unlocked_ioctl=mychar_ioctl,
 .poll=mychar_poll,
 .fasync=mychar_fasync,
};


int __init  mychar_init(void)
{
	int ret = 0;
	dev_t  devno = MKDEV(major,minor);
	int i=0;
	/*申请设备号*/
	ret = register_chrdev_region(devno,mychar_num,"mychar");
	if (ret)
	{
	  ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
	  if (ret)
	  {
		printk("get devno failed\n");
		return -1;
	  }
		major = MAJOR(devno);//容易遗漏，注意
	}

	for(i=0;i<MYCHAR_DEV_CNT;i++)
	{
          devno=MKDEV(major,minor+i);
	  /*给struct cdev对象指定操作函数集*/
      	  cdev_init(&gmydev_arr[i].mydev, &myops);

	  /*将struct cdev对象添加到内核对应的数据结构里*/
       	  gmydev_arr[i].mydev.owner = THIS_MODULE;
       	  cdev_add(&gmydev_arr[i].mydev,devno,1);
          init_waitqueue_head(&gmydev_arr[i].rq);
          init_waitqueue_head(&gmydev_arr[i].wq);
	}


       return 0;
}

void __exit mychar_exit(void)
{
   dev_t devno = MKDEV(major, minor);
   int i=0;
   for(i=0;i<MYCHAR_DEV_CNT;i++)
   {
     cdev_del(&gmydev_arr[i].mydev);
   }
   unregister_chrdev_region(devno,mychar_num);
}

MODULE_LICENSE("GPL"); 

module_init(mychar_init); 
module_exit(mychar_exit);
自然醒欧
关注
专栏目录
2021-02-08/09 大数据课程笔记 day19day20 某大型网站日志分析离线系统
qq_44745905的博客
02-10 4586
@R星校长 某大型网站日志分析离线系统 项目需求分析 概述 该部分的主要目标就是描述本次项目最终七个分析模块的界面展示。 工作流   在我们的 demo 展示中，我们使用 jquery+echarts 的方式调用程序后台提供的 rest api 接口，获取 json 数据，然后通过 jquery+css 的方式进行数据展示。工作流程如下： 分析 总述 在本次项目中我们分别从七个大的角度来进行分析，分别为： 用户基本信息分析模块 浏览器信息分析模块 地域信息分析模块 用户浏览深度分析模块 外链数据分析模块 .
BigchainDB白皮书，中文翻译
热门推荐
fengqing79的专栏
04-13 1万+
BigChainDB：可扩展区块链数据库 这篇白皮书介绍BigChainDB。BigChainDB填补了去中心生态系统中的一个空白：是一个可用的去中心数据库。它具有每秒百万次写操作，存储PB级别的数据和亚秒级响应时间的性能。BigChainDB的设计起始于分布式数据库，通过创新加入了很多区块链的特性，像去中心控制、不可改变性、数字资产的创建和移动。BigChainDB继承了现代分布式数据库的特性
linux内核驱动模型
08-29
linux内核驱动模型linux内核驱动模型linux内核驱动模型
【Linux】内核驱动篇四--IO模型
修成真的博客
05-17 1168
内核驱动篇四--IO模型一、五种IO模型------读写外设数据的方式二、阻塞与非阻塞三、多路复用3.1 应用层：三套接口select、poll、epoll3.2 驱动层：实现poll函数四、信号驱动4.1 应用层：信号注册+fcntl4.2 驱动层：实现fasync函数 一、五种IO模型------读写外设数据的方式 阻塞: 不能操作就睡觉 非阻塞：不能操作就返回错误 多路复用：委托中介监控 信号驱动：让内核如果能操作时发信号，在信号处理函数中操作 异步IO：向内核注册操作请求，内核完成操作.
Linux内核驱动--硬件访问I/O【原创】
weixin_34392906的博客
05-16 96
寄存器与内存         寄存器与内存的区别在哪里呢？ 寄存器和RAM的主要不同在于寄存器操作有副作用（side effect或边际效果）： 读取某个地址时可能导致该地址内容发生变化，比如很多设备的中断状态寄存器只要一读取，便自动清零。 内存与IO 在X86处理器中存在IO空间的概念，IO空间是相对内存空间而言的，他们是彼此独立的地址空间，在32位的x86系统中，IO空间大小只有64...
linux驱动IO模型
m0_58318591的博客
09-26 241
linux驱动io模型
嵌入式系统驱动初级【4】——字符设备驱动基础中_IO模型
imysy_22_的博客
08-03 201
五种IO模型------读写外设数据的方式
Java面试题
HackAge4619的博客
03-02 6714
N年前收集的面试题都放在这了，Java基础，前端，框架，数据库等…… 针对面试初级 一起复制的，有点乱，自己整理一下吧！ jdbc的原理，怎么连接数据库的？ 需要深入的了解 1）在开发环境中加载指定的数据库驱动程序  导入数据库驱动包 2）加载驱动程序  java程序中，通过Class.forName来指定数据库的驱动程序  3）创建数据库连接对象  通过DriverManager类创建
剖析虚幻渲染体系（14）- 延展篇：现代渲染引擎演变史Part 1（萌芽期）
www_xuhss_com的博客
04-04 5606
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 目录* 14.1 本篇概述 + 14.1.1 游戏引擎简介 + 14.1.2 游戏引擎模块 + 14.1.3 游戏引擎列表 - 14.1.3.1 Unreal Engine - 14.1.3.2 Unity - 14.1.3.3 CryEngine - 14.1.3.4 Doo
JavaScript笔记
shine_my的博客
03-13 3334
JavaScript笔记
linux下IO口驱动
10-21
linux下IO口驱动,可随意控制IO口输出高低电平
linux下IO口驱动（2）
10-21
IO口驱动，可随意控制IO口输出任意电平
Linux内核的IO模型详解
xylitolz的博客
08-29 539
文章目录一、什么是IO二、Linux内核的IO模型2.1 概念说明2.1.1 用户空间和内核空间2.1.2 进程切换2.1.3 进程的阻塞2.1.4 文件描述符2.1.5 缓存 IO2.2 同步阻塞2.3 同步非阻塞2.4 IO复用2.5 信号驱动2.6 异步非阻塞 本篇文章已同步更新至Github仓库JavaSummary，欢迎star! 一、什么是IO 在Linux的世界，一切皆文件。而文件是什么呢，文件就是一串二进制流。不管socket、FIFO、管道还是终端，对我们来说，一切都是流。在信息的交
嵌入式学习之Linux驱动：IO模型（1）概览
最新发布
似水流年
12-22 1561
IO的英文全称是input和output，翻译过来就是输入和输出。在冯诺依曼结构中，将计算机分成为5个部分：运算器、控制器、存储器、输入设备、输出设备。其中输入设备指的是向计算机输入数据或信息，如鼠标，键盘都是输入设备。输出设备指的是用于接收计算机输出信息的设备，如电脑显示器。
linux io模型
zhaozhenzuo的专栏
08-21 1054
netty
linux驱动内核模型
Henry_He 的专栏
12-10 7672
内核驱动模型的初衷2.6内核增加了一个引人注目的新特性——统一设备模型(devicemodel)。设备模型提供了一个独立的机制专门来表示设备，并描述其在系统中的拓扑结构，从而使得系统具有以下优点：l        代码重复最小化。l        提供诸如引用计数这样的统一机制。l        可以列举系统中所有的设备，观察它们的状
深入底层，Linux五种IO模型全解析
毛毛的专栏
11-15 512
文章目录一、前言二、Java IO与操作系统IO2.1 Java层面的三种IO 与 操作系统层面的五种IO2.2 到底什么是IO三、五种IO3.1 第一种：阻塞IO模型3.2 第二种：非阻塞IO模型3.3 第三种：信号驱动IO模型3.4 第四种：IO复用模型，线程池3.5 第五种：异步IO模型3.6 五种IO模型对比四、面试金手指五、尾声 一、前言 二、Java IO与操作系统IO 2.1 Java层面的三种IO 与 操作系统层面的五种IO 在Java中，主要有三种IO模型，分别是阻塞IO（BIO）、非阻塞
linux驱动开发：IO模型
m0_70983574的博客
08-30 829
简单介绍了驱动开发中的几种IO模型
Linux内核之IO1: I/O模型
科学边界
08-27 812
在业务执行过程中，常伴随大量的IO操作，如果IO操作和CPU消耗不能合理安排，将会导致整体业务执行效率低下，用户体验极差。 比如手机启动过程，有大量CPU消耗和IO操作。用Bootchart记录android启动过程的CPU/IO消耗如下图 Systemd readahead: Systemd readahead-collect.service搜集系统启动过程中的文件访问信息，Systemd readahead-replay.service在后续启动过程中完成回放，即将IO操作与CPU并行； 提高效率的
Java IO理解：字节流与字符流解析
在Java编程中，IO流（Input/Output Stream）是处理数据传输的核心部分，主要用于在不同设备之间进行数据的读取和写入。在描述的文档中，提到了以下几个关键知识点： 1. **IO流的概念**：IO流是一种模拟数据传输的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

自然醒欧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值