基于文件页的 LRU Cache：磁盘缓存实现

最新推荐文章于 2022-09-07 22:24:40 发布
置顶 最新推荐文章于 2022-09-07 22:24:40 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： 操作系统/网络 文章标签： cache 服务器 磁盘缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/quzhongxin/article/details/46700787
版权
本文详细介绍了如何在服务器端实现一种基于文件页的LRUCache，通过磁盘缓存模式加速磁盘文件的查找。实现了读写缓存共用、写回策略、LRU策略和散列查找，以提高磁盘访问效率。讨论了实现过程中的缺点及改进方法，包括建立key和文件之间的映射表，以减少磁盘I/O操作，提升效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

基于文件页的 LRU Cache：磁盘缓存实现

1. 功能需求

本文链接：http://blog.youkuaiyun.com/quzhongxin/article/details/46700787

在服务器实现过程中，服务端需要接受客户端的get和put两种操作，
put(key, value): 在接收一定数量的数据后需要将数据保存到磁盘上，并且需要检查是否存在相同的key；
get(key): 向服务端查询是否存在该key；
上述两种操作都涉及了磁盘文件的操作，由于磁盘 IO 访问速度慢，因此为了加速在磁盘文件中的查找，本文实现了一种Hash LRU Cache.

HashCache 实现了一种基于文件页的LRU Cache 功能，通过建立磁盘缓存的模式，实现了对磁盘文件的快速查找。

2. 实现思想

  • 写回策略：读写缓存共用，将数据写入到缓存，当数据被置换出cache时，将dirty数据同步到磁盘。（多次修改一次写回）。更多缓存策略
  • LRU 策略：由于cache的空间时一定的，且根据局部性原理，置换最久未被访问（get or put）的页面，将极大减少磁盘文件的访问，提高效率。了解更多
  • 散列：为了在cache中快速检索，将cache中的数据按散列表的形式组织，实现O(1)访问

3. 缺点

存在一致性问题。

4. 实现过程

<注> LRU 中使操作的单位是page， hash_table 中存储的是每一个page中的所有数据节点的地址，即操作单位是node*，LRU和hash_table中的数据节点的value值会同步修改。LRU用以存储，HashTable用以查找，二者之间是映射关系，但不是在地址上顺序映射的。
这里写图片描述

  1. 设定 Cache 包含 N 页，每页可以容纳 M 个数据节点，使每M个数据节点有对应的一页
  2. 设定 每个磁盘文件的大小为 M，即一页对应一个文件（因为实在不知，如何更简便的对一个文件实现部分修改）
  3. 对磁盘文件编号，使页和文件形成对应关系
  4. get(key) 操作，查找是否有关键字key对应的数据。
    • 4.1 在 hash_table 中查找，成功则结束查找；
    • 4.2 hash_table 查找失败后，需要查找磁盘文件；按文件的创建日期由新到旧依次加载到hash_table 和 LRU cache中的一个page中，每次加载后，都从hash_table 中查找key,成功则结束查找
      • 如果在加载某个磁盘文件后查找失败，需要将该文件对应的page从LRU cache 和 hash_table 中删除；
      • 如果在加载某个磁盘文件后查找成功，需要将该文件对应的page保留在hash_table中，并放到LRU Cache前列（标记为最近访问）；
      • 如果已加载完所有文件，仍然查找失败，结束查找，返回查找失败
    • 4.3 在多次的get操作查找成功后，LRU cache中会保存很多page，直至LRU cache中没有空闲的page，此时应该按需删除最久未被访问过的page，如果该页是dirty的，需要将page写回到文件
  5. put(key, value) 操作，向 server 端添加该节点的信息，若已存在相同key则覆盖
    • 5.1 在hash_table中查找，如果查找成功，则覆盖节点value，设置该节点对应的页是dirty的
    • 5.2 hash_table中查找失败，如get操作中在磁盘文件中查找，查找成功则保留该页在LRU 和 hash_table 中，并覆盖修改key对应的value，同时标记该页为dirty
    • 5.3 磁盘文件也查找失败，需要新建一页（put_page）存储新的节点，put_page 和 其他 page 同样在LRU链表中移动。
      • 只是当 put_page 未写满M个数据，且没有因为存储其他数据而被弹出cache时，新的put(key, value)仍然写入到该put_page
      • 当一个 put_page 已经写满M或被弹出时，向LRU cache重新申请一个put_page用于存储

2015/07/19更新

建立key和文件之间的映射表

为了快速的定位一个key对应的文件，而不是不断的逐个遍历文件来定位，提出以下改进：

  • 对于上文步骤5.3中put操作，当put_page已经写满时，将该put_page中的所有key和put_page->file_num组成（key，filenum）映射对，存储在哈希表key-file-map中；例如put_page中有2个数据，put_page分配的文件标号为2，则压入(key1, 2) (key2, 2)进key-file-map
  • 对于上文中put或者get操作涉及的查找key的操作，首先在hash-table中查找，失败后则在key-file-map中查找是否有存在该key的数据文件，如果查找到，则加载key对应的文件进新的一页，然后在hash-table中得到key的节点；如果没查找到，说明不存在含有key的数据文件，服务器不存在该key。
  • 服务器在启动时，应该首先把存储在文件中的key-file映射表加载到内存(key-value-map)中。

以上改进，避免了原始方法中的不断遍历文件时大量的磁盘IO操作，这将极大地提高效率。但是缺点是，维持key-file-map需要占用内存。如果value的数据量 远远大于 文件标号(int 型数据) 的数据量时，此项改进是有意义的。

改进代码，请访问：key/value服务器项目: https://github.com/qzxin/key-value-server

5. C++实现源码

基于VS2015 调试开发，支持C++11的编译器均可，
MinGw编译器存在已知bug（由于std::to_string函数）：查看bug
gcc 测试成功g++ -std=c++11 main.cpp hash_cache.cpp -o hash_cache

5.1 hash_cache.h

/*
 *  hash_cahce.h
 *  
 *  Author: quinn
 *  Date : 2015/06/30
*/
#ifndef HASH_CACHE_H
#define HASH_CACHE_H
#include <vector>
#include <unordered_map>
#include <fstream>
#include <string>
//#include "node.h"
#define PAGE_SIZE 2
#define CACHE_SIZE 2
#define DISK_SIZE 20
#define FAILED -1
using namespace std;
// 类 HashCache 实现了一种基于文件页的LRU Cache的功能，Cache 空间一定，当 Cache 已经被占满时，需要删除最久未被访问过的页。
// 如果该页被修改过，则需要重新写回到文件；
//包含 put 和 get 两种操作
// put 操作：向 缓存中添加该节点的信息，若已存在相同key，则覆盖。删除页时
// get 操作：搜索
class HashCache {
private:
    class Page;
    class Node;
    Page* entries_;
    vector<Page*> free_entries_;  // 存储空闲page
    unordered_map<string, Node* > hash_map; // 存储节点的散列表，以供快速查询
    Page* get_new_page(); // 得到新的一页，可处理没有空页的情况
    Page* put_page;  // 用以标记写入的page
    bool put_page_existed;  // 用于put_page被顶出之后的判断
    const char**file_list_; // 已弃用。文件列表，后来采用直接用文件序号直接构造文件名。
    int new_file_index_; // 新建文件序号，初始为 -1
    Page *head_, *tail_; // 双向列表的头尾，以实现LRU Cache
    void detach(Page* page);  // 卸载该页
    void attach(Page* page);  // 将该页链接到头部

    Node* search(string key);  // 搜索key，成功返回 key 代表的节点，失败返回NULL
    int load_file_to_page(const int &file_num, Page* &page, unordered_map<string, Node* > &hash_map); // 将第file_num个文件加载到page中，并推入hash_map的表中
    int save_page_to_file(Page* &page);  // 将page保存到文件
    void erase_page_of_cache(Page* &page, unordered_map<string, Node* > &hash_map);  // 将该页的内容从hash_map中释放

    int load_new_file_index(const char* save_file_index = "file_index.dat"); // 在该文件中存储着存储文件已经使用到第几个；加载失败返回-1
    void save_new_file_index(const char* save_file_index = "file_index.dat");  // 程序结束时，保存现在的文件序号到文件

public:
    HashCache(int capacity = CACHE_SIZE);
    ~HashCache();
    void save_cache();  //将cache中所有dirty（已修改）内容保存到文件（可以定期调用或者最后结束程序时调用）
    string get(string key);
    void put(string key, string value);
};
#endif

5.2 hash_cache.cpp

/*
 *  hash_cahce.cpp
 *  
 *  Author: quinn
 *  Date : 2015/06/30
*/
#include "hash_cache.h"
#include <iostream>
#include <algorithm>
using namespace std;
bool file_accessed[DISK_SIZE] = { false };

// 单个数据节点
class HashCache::Node {
public:
    std::string key_;
    std::string value_;
    class Page* page_;  // 该数据节点所属页
};

// 一页
class HashCache::Page {
public:
    int file_num_; // 页所对应的文件序号
    bool lock_;
    bool dirty_;  // 标记page是否被修改
    class Node data_[PAGE_SIZE];  // 页包含的节点数据
    class Page* next;
    class Page* prev;
    Page() {
        lock_ = false;
        dirty_ = false;
    }
};

HashCache::HashCache(int capacity) {
    // file_list_ = file_list;
    new_file_index_ = load_new_file_index();
    put_page_existed = false;
    // 为cache分配内存
    entries_ = new Page[capacity];
    for (int i = 0; i < capacity; i++) {
        for (int j = 0; j < PAGE_SIZE; j++)  // 将该页的地址标记到节点中
            (entries_ + i)->data_[j].page_ = entries_ + i;
        free_entries_.push_back(entries_ + i); // 页入队列
    }
    // 构建双向链表
    head_ = new Page;
    tail_ = new Page;
    head_->prev = NULL;
    head_->next = tail_;
    tail_->prev = head_;
    tail_->next = NULL;
}
HashCache::~HashCache() {
    // 保存cache的数据
    save_cache();
    //delete entries_;
    delete head_;
    delete tail_;
}

// 查找 key ： 先在当前 hash_map 中查找，不成功则依次查找现有文件中的数据；
// 查找文件过程中，如果查找成功，则该文件中的数据保留到hash_map中，所属页链接到LRU双向链表头部；失败，则删除其对应的所有信息，恢复之前的状态
// get 操作 和 put 操作 都要调用此函数
HashCache::Node* HashCache::search(string key) {
    Node* node = hash_map[key];
    Page* page = NULL;
    if (node) {
        // search success, 将节点所属页链到头部
        page = node->page_;
        detach(page);
        attach(page);
    }
    else {
        // 优先遍历最新的文件
        for (int file_num = new_file_index_; file_num >= 0; file_num--) {
            if (file_accessed[file_num] == true)
                continue;  // 该文件曾经存在或正存在于hash_map 中，跳过

            page = get_new_page(); // 从空间中获取一个新page
                                   // 将当前文件加载进page，并把数据插入到hash_map
            if (load_file_to_page(file_num, page, hash_map) == FAILED) {
                free_entries_.push_back(page); // 加载失败，重新将该page入栈
                continue;
            }

            if (node = hash_map[key]) {
                attach(page);
                break;  // 已找到该节点
            }
            else {
                // 该文件不含查找节点，释放掉该文件对应页
                erase_page_of_cache(page, hash_map);
                free_entries_.push_back(page);
            }
        }
    }
    return node;
}

string HashCache::get(string key) {
    Node* node = search(key);
    if (node)
        return node->value_;
    return string(); // 查找失败返回默认值
}
// put 操作：将数据写入到server；当已经存在同样的key时，覆盖 ;
//        因此，首先先查找是否存在key，存在则覆盖值，并且将页标为dirty；不存在，将数据写入到 put_page 中。
//                  最后都要将操作页链到头部.
//  注：此处的put_page一直接受put操作的值，直至满页后，put_page才指向新的一页，当被弹出时，写入到磁盘
void HashCache::put(string key, string value) {
    Node* node = NULL;
    node = search(key);
    if (node) {  // 存在当前key
        if (value != node->value_) {
            node->value_ = value;
            node->page_->dirty_ = true;
        }
        return;
    }
    else {
        // server 不存在当前节点，写入put_page
        static int data_index = 0;
        // 上一次的 put_page 没有写满，但是被弹出了，即 put_page 不存在，新的一页新的数据索引
        if (data_index == PAGE_SIZE || put_page_existed == false) {
            data_index = 0;
        }
        if (data_index == 0 || put_page_existed == false) { //和上一语句代码冗余， put_page_existed == false 可以不存在，仅便于理解
                                                            // put_page 初始化
            put_page = get_new_page();
            put_page_existed = true;
            put_page->file_num_ = ++new_file_index_; // put_page 对应文件序号
            put_page->dirty_ = true;
            for (int i = 0; i < PAGE_SIZE; i++) {
                put_page->data_[i].key_ = "";
                put_page->data_[i].value_ = "";
            }
            attach(put_page);
        }
        put_page->data_[data_index].key_ = key;
        put_page->data_[data_index].value_ = value;
        hash_map[key] = put_page->data_ + data_index;  // 加入到散列表
        data_index++;
        detach(put_page);
        attach(put_page);
    }
}


// 将第file_num个文件加载到page中，并推入hash_map的表中
int HashCache::load_file_to_page(const int &file_num, Page* &page, unordered_map<string, Node* > &hash_map) {
    ifstream input;
    string file_name = to_string(file_num) + ".dat"; // 用文件编号构造文件名
    input.open(file_name, ios::in);
    if (!input || page == NULL)
        return FAILED; // 不存在文件
    file_accessed[file_num] = true;  // 表示该文件已经存在于hash_map
    page->file_num_ = file_num;
    Node* data = page->data_;
    for (int i = 0; i < PAGE_SIZE; i++) {
        if (!(input >> data[i].key_ >> data[i].value_))
            data[i].key_ = "", data[i].value_ = ""; // 输入为空
        hash_map[data[i].key_] = data + i;
    }
    input.close();
    return 0;
}
int HashCache::save_page_to_file(Page* &page) {
    page->dirty_ = false;
    if (page == NULL)
        return FAILED;
    ofstream output;
    string file_name = to_string(page->file_num_) + ".dat"; // 用文件编号构造文件名
    output.open(file_name, ios::out);
    Node* data = page->data_;
    for (int i = 0; i < PAGE_SIZE; i++) {
        output << data[i].key_ << " " << data[i].value_ << endl; // 将该页中的节点保存到文件中
    }
    output.close();
    return 0;
}

//加载文件序号，以便server重启后的文件不会产生覆盖；
//加载失败返回-1 （使用前先自增操作，因此从 0 号文件开始）
int HashCache::load_new_file_index(const char* save_file_index) {
    ifstream input;
    input.open(save_file_index, ios::in);
    if (!input) {
        return -1; // 不存在该文件，返回初始序号 -1
    }
    int index;
    input >> index;
    input.close();
    return index;
}
void HashCache::save_new_file_index(const char* save_file_index) {
    ofstream output;
    output.open(save_file_index, ios::out);
    if (!(output << new_file_index_)) {
        cout << "保存存储文件序号文件失败：write <" << save_file_index << "> failed." << endl;
        exit(-1);
    }
    output.close();
}

void HashCache::erase_page_of_cache(Page* &page, unordered_map<string, Node* > &hash_map) {
    file_accessed[page->file_num_] = false; // 表示该文件已经不再hash_map中
    for (int i = 0; i < PAGE_SIZE; i++) {
        hash_map.erase(page->data_[i].key_);
    }
}

void HashCache::save_cache() {
    // 保存搜索用hash_map
    Page* page = head_->next;
    while (page != tail_) {
        if (page->dirty_ == true) {
            save_page_to_file(page);
        }
        page = page->next;
    }
    save_new_file_index();
}

void HashCache::detach(Page* page) {
    page->prev->next = page->next;
    page->next->prev = page->prev;
}
void HashCache::attach(Page* page) {
    page->prev = head_;
    page->next = head_->next;
    head_->next->prev = page;
    head_->next = page;
}

// 从cache中分配新的一页：cache有空闲和cache已满
// cache有空闲：从空闲列表中取出一页，返回
// cache已满：需要释放一页才能给出一页空间；
//                      选择释放最后的一页，并且当该页是dirty的，则写入page到文件；当该页是一个未满的put_page，标记为cache中已不存在put_page
// <注> 释放包括：从链表中取出 和 从 hash_map 表中删除该页包含的所有节点信息
HashCache::Page* HashCache::get_new_page() {
    Page* page;
    if (free_entries_.empty() == true) {
        // cache 已满，从尾部取下一个page
        page = tail_->prev;
        if (page == put_page)  // put_page 被顶出
            put_page_existed = false;
        if (page->dirty_ == true)
            save_page_to_file(page); // 保存该页，并从hash_map中删除该页
        erase_page_of_cache(page, hash_map);
        detach(page);
        free_entries_.push_back(page); //之所以入栈又出栈，是为了应对读取失败的情况
    }
    page = free_entries_.back();
    free_entries_.pop_back();
    return page;
}

6. 工程文件下载

LRU Cache & Disk Write-Back: http://download.youkuaiyun.com/detail/quzhongxin/8857439
key/value服务器项目: https://github.com/qzxin/key-value-server

Glide源码学习笔记六：磁盘缓存实现
liuyuzhou_的博客
07-13 558
Glide磁盘缓存实现
LRU缓存机制实现（cpp版）
IamCerian的博客
02-25 735
文章目录一、概念二、算法描述三、算法思想四、代码及具体思路 一、概念 计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。但问题是，删除哪些内容呢？我们肯定希望删掉哪些没什么用的缓存，而把有用的数据继续留在缓存里，方便之后继续使用。那么，什么样的数据，我们判定为「有用的」的数据呢？ LRU 缓存淘汰算法就是一种常用策略。LRU 的全称是 Least Recently Used，即最...
.net缓存——基于文件的缓存
weixin_33985507的博客
05-26 235
一，.Net中的缓存基础知识 .net中支持的两种依赖： CacheDependency SqlDependency 表示对于文件或者目录的依赖 表示对于SQL数据库的依赖 过期时间 绝对过期时间 滑动过期时间 一个特定的时间点，类型为DateTime 一个时间间隔，...
文件缓存
fengsh2014的博客
08-20 758
在我们平时的项目中往往很多时候需要做一些数据缓存，如聊天中的图片、语音、视频、文件等；因此写了篇文章，如有不妥之处，还望大家能不吝赐教，谢谢 由于功能并不复杂，就不多说了，直接上代码 KFileCache.h文件 // // KFileCache.h // KXiniuCloud // // Created by RPK on 2018/8/14. // Copyright © 2...
动手实现一个磁盘高速缓存：准备工作(一)
路在脚下
12-08 983
要想实现一个独立于Linux内核的磁盘高速缓存，就需要确定磁盘高速缓存的数据放到什么地方，因为在Linux中申请大块内存的不确定性和不稳定性，我们使用在开机时预留大块内存的方式，独立管理这块被保留的内存存放磁盘缓存数据； 在开机时预留大块内存，需要修改Linux内核的源代码文件（init/main.c），在内存初始化之前预留出一部分内存，我使用的内核版本是3.8.13，下面是需要修改的cod
基于文件的快速KV缓存系统BoomKV.zip
07-19
给我一大堆数据，我还你一个基于文件的快速的 KV 缓存系统BoomKV 是一个更加适用于大数据环境，设计新颖的 KV 缓存系统测试结果：i5 8G，10w数据，随机访问里面的 key, QPS 6w 左右 标签：BoomKV
Expirable Disk Lru Cache：实现可设定到期时间的磁盘缓存
DiskLruCache是Android平台提供的一个用于管理磁盘缓存的工具类，特别适合那些需要缓存大量数据以减少网络请求的应用程序。ExpirableDiskLruCache在此基础上引入了时间戳机制，使得缓存项可以根据设定的过期时间自动...
lru:用 Go 编写的磁盘上的 LRU 缓存
07-08
现在，这个缓存： 不允许更新（尚未实施更新） 永远不会超过限制（我们在写入磁盘之前检查而不是在调整之后） 初始化时应该为空（我们不删除任何内容，但是 2 个不同实例上的 2 个键将具有相同的文件名，因此值...
HashCache实现LRU页面缓存-磁盘快速查找技术
HashCache通过哈希表来快速定位文件页，实现高效的LRU页面缓存。哈希表的键通常是文件页的标识符，而值则是对应文件页的数据。哈希表允许快速查找和更新操作，从而支持LRU缓存的高效运行。 当一个页面被访问时，它...
AndroidDiskCache:一个基于LRU的基本android缓存实现，用于以键值对的形式在磁盘中存储信息
05-13
Android磁盘缓存是基于LRU的磁盘缓存，可将您的android pojo / data对象以键值格式保存在手机的内存中。 它使用对象的JSON表示的出色库（使用出色的库）和对象的内存中运行时缓存。 您可以选择指定这些缓存条目到期...
lru工具：高效管理LRU文件缓存的Go语言实现
lru文件系统缓存修剪工具是一个基于LRU算法的实用程序，专门用于维护文件系统的LRU缓存。 知识点一：LRU缓存机制 LRU缓存机制是一种内存管理策略，它基于局部性原理，即最近被访问的数据很可能在不久的将来再次被...
操作系统实验报告 磁盘调度 先进先出算法 lru算法
07-11
操作系统实验报告 磁盘调度 先进先出算法 lru算法 操作系统实验报告 磁盘调度 先进先出算法 lru算法操作系统实验报告 磁盘调度 先进先出算法 lru算法
LRU缓存机制
浮华饰浮华的博客
01-31 535
LRU是最近最少使用页面置换算法(Least Recently Used),也就是首先淘汰最长时间未被使用的页面! 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(k...
操作系统磁盘缓存
suyue466300750的博客
11-21 1323
高速磁盘缓存高速磁盘缓存可大致分为以下三种： - 目录项高速缓存——主要存放的是描述文件系统路径名的目录项对象 - 索引节点高速缓存——主要存放的是描述磁盘索引节点的索引节点对象- 页高速缓存——主要存放的是完整的数据页对象，每个页所包含的数据一定属于某个文件，同时，所有的文件读写操作都依赖于页高速缓存。
DiskLruCache 达到最大设置的缓存，清理的逻辑
lnkywd的博客
08-28 1180
关于 DiskLruCache 的使用还有源码的解析，可以参考 郭神 和 鸿洋大神 的两篇文章 Android DiskLruCache完全解析，硬盘缓存的最佳方案 Android DiskLruCache 源码解析 硬盘缓存的绝佳方案 在 DiskLruCache 中的 open 方法中 public static DiskLruCache open(File directory
【文件系统】LRU算法
Edidaughter的博客
11-07 433
1.什么是LRU算法 LRU(Least Recently Used),最近最少使用,是一种内存算法.LRU算法基于一种假设：长期不被使用的数据，在未来被用到的几率也不大. 因此，当数据所占内存达到一定阈值时，要移除掉最近最少使用的数据.LRU算法使用了一种有趣的数据结构，叫做哈希链表. 2.什么是哈希链表 在现在的内核实现中，我们的文件的Inode底层的存储结构就是哈希链表. 比如说我们现在有文件的inode是00001 ...
LRU算法学习笔记：实现以及应用
zsiming的博客
09-07 729
所谓LRU（Least Recently Used）就是最近最少使用算法。其核心的思想就是根据每个节点的最后一次访问事件来对每个结点进行排序。最近一次使用的排在队头，依次类推。
自己实现一个LRU缓存
力尽山拔的博客
10-28 155
#include <bits/stdc++.h> using namespace std; class Node{ public: int key; int value; Node* left; Node* right; Node(int x,int y): key(x),value(y),left(NULL),right(NULL){} }; Node* dummyLeft = NULL; Node* dummyRight = NULL; int c.
15.操作系统——文件IO,page cache保证内存与磁盘一致性与设备管理
strive for the best 的博客
07-09 1963
Linux 存储系统的 I/O 软件分层，分为三个层次，分别是文件系统层、通用块层、设备层。常见的IO分为三类： 缓冲与非缓冲 I/O 直接与非直接 I/O 阻塞与非阻塞 I/O VS 同步与异步 I/O阻塞 I/O、非阻塞 I/O，还是基于非阻塞 I/O 的多路复用都是同步调用。因为它们在 read 调用时，内核将数据从内核空间拷贝到应用程序空间，过程都是需要等待的，也就是说这个过程是同步的，如果内核实现的拷贝效率不高，read 调用就会在这个同步过程中等待比较长的时间。1.缓冲与非缓冲IO 根据是否利用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值