AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

细谈 Linux 中的多路复用epoll

2024-11-05 41
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 大家好，我是 V 哥。`epoll` 是 Linux 中的一种高效多路复用机制，用于处理大量文件描述符（FD）事件。相比 `select` 和 `poll`，`epoll` 具有更高的性能和可扩展性，特别适用于高并发服务器。`epoll` 通过红黑树管理和就绪队列分离事件，实现高效的事件处理。本文介绍了 `epoll` 的核心数据结构、操作接口、触发模式以及优缺点，并通过 Java NIO 的 `Selector` 类展示了如何在高并发场景中使用多路复用。希望对大家有所帮助，欢迎关注威哥爱编程，一起学习进步。

大家好，我是 V 哥。在 Linux 中，epoll 是一种多路复用机制，用于高效地处理大量文件描述符（file descriptor, FD）事件。与传统的select和poll相比，epoll具有更高的性能和可扩展性，特别是在大规模并发场景下，比如高并发服务器。

以下是epoll的核心数据结构和实现原理：

1. epoll的核心数据结构

在 Linux 内核中，epoll的实现涉及多个核心数据结构，主要包括以下几个：

(1) epoll实例

epoll在创建时，会生成一个与之关联的实例，这个实例在内核中是一个epoll文件对象（struct file），并且与用户态的epoll文件描述符（FD）对应。该实例负责维护和管理所有加入的事件。

(2) 事件等待队列（epitem）

epoll中的每个事件都被封装成一个epitem结构。该结构体主要包括以下几个关键内容：

  • 指向被监听文件的指针：用于标识监听的文件对象。
  • 事件类型和事件掩码：指定关注的事件类型（如可读、可写、异常等）。
  • 双向链表节点：用于将所有的epitem结构体组织成链表（或红黑树）。

(3) 红黑树（RB-Tree）

为了快速查找和管理epitem，epoll使用红黑树将所有的epitem组织起来。每个被监听的文件描述符及其事件类型会存储在红黑树中，通过这种方式，可以在事件添加、删除、修改时实现高效的查找和管理。

(4) 就绪队列（Ready List）

当监听的文件描述符上发生指定的事件时，epoll会将该文件描述符的事件加入一个就绪队列。这个队列是一个双向链表，存储所有准备好处理的epitem。当用户调用epoll_wait时，内核从该队列中取出满足条件的事件并返回。

2. epoll的三种操作

epoll提供三种主要的操作接口：epoll_create、epoll_ctl 和 epoll_wait。

(1) epoll_create

epoll_create用于创建一个epoll实例，并返回一个文件描述符。它会在内核中分配epoll数据结构，并初始化就绪队列、红黑树等结构。它主要完成以下任务：

  • 分配一个epoll实例，并初始化相关的数据结构。
  • 创建一个文件描述符供用户引用。

(2) epoll_ctl

epoll_ctl用于将事件添加到epoll实例中，或从epoll实例中移除，或修改现有事件。具体操作包括：

  • 添加事件（EPOLL_CTL_ADD）：将新事件添加到epoll中，即将文件描述符及其事件掩码包装成epitem结构体，然后插入红黑树。
  • 删除事件（EPOLL_CTL_DEL）：将事件从epoll实例中移除，即从红黑树中删除对应的epitem。
  • 修改事件（EPOLL_CTL_MOD）：修改现有的事件，比如修改事件掩码或回调方式。

通过红黑树结构，epoll_ctl操作的添加、删除、修改事件在平均时间复杂度上为 (O(\log N))，相较于poll的线性复杂度更具性能优势。

(3) epoll_wait

epoll_wait用于等待文件描述符上的事件，直到有事件触发或超时。其主要过程包括：

  • 遍历就绪队列，将所有已经准备好的事件放入用户态缓冲区，并清空队列。
  • 如果没有事件发生，内核会让调用线程进入休眠状态，并在监听的事件发生后唤醒。
  • epoll会利用中断机制高效地唤醒阻塞在epoll_wait上的线程，从而实现事件驱动的处理方式。

epoll_wait只需遍历就绪队列中的事件，而不是遍历所有的监听事件，这使得性能相较于select和poll有显著提升。特别是在大量文件描述符中仅有少数活跃时，epoll_wait的优势更为明显。

3. epoll的触发模式

epoll提供两种触发模式来控制事件的触发方式：

(1) 水平触发（LT, Level Triggered）

在默认的水平触发模式下，只要文件描述符上有指定的事件（如数据可读），每次调用epoll_wait都会返回此事件，除非事件被处理（如数据被读走）。这是与poll和select一致的行为。

(2) 边缘触发（ET, Edge Triggered）

在边缘触发模式下，epoll_wait只会在事件第一次发生时通知，之后即使该事件条件一直满足（如数据仍可读），也不会再次触发，除非事件条件有新的变化。该模式能够减少不必要的系统调用次数，但要求应用程序在接收到通知后必须一次性处理所有数据，否则可能会错过事件。

4. epoll的优缺点

优点：

  • 高效的事件监听：使用红黑树管理监听事件，提高了事件的增删查效率。
  • 事件驱动的高并发处理：通过边缘触发模式，减少系统调用次数，适合高并发场景。
  • 就绪事件分离：就绪队列与监听列表分离，不必遍历所有文件描述符，从而大大提升了性能。

缺点：

  • 只支持 Linux：epoll是 Linux 特有的实现，跨平台兼容性较差。
  • 编程复杂度：相比select和poll，epoll需要更精细的控制，特别是在边缘触发模式下应用程序需要处理全部数据，以防止事件丢失。

5. Java NIO 如何使用多路复用

下面 V 哥用案例来详细说一说Java 中的多路复用。在 Java NIO 中，Selector 类实现了多路复用机制，底层使用 epoll 或 poll 实现。Java NIO 中的多路复用非常适合处理大量并发连接，比如在高并发的服务器场景中。以下是使用 Java NIO 和 Selector 创建一个简化的聊天服务器示例，通过多路复用处理多个客户端连接。

示例：NIO 实现的聊天服务器

这个服务器使用 ServerSocketChannel 来监听客户端连接，通过 Selector 监听和管理事件，并使用 SocketChannel 处理每个连接。客户端连接后可以发送消息，服务器会将消息广播给所有其他连接的客户端。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.*;

public class WGNioChatServer {
   
    private final int port;
    private Selector selector;
    private ServerSocketChannel serverSocketChannel;
    private final Map<SocketChannel, String> clientNames = new HashMap<>(); // 保存客户端名称

    public WGNioChatServer(int port) {
   
        this.port = port;
    }

    public void start() throws IOException {
   
        // 初始化服务器通道和选择器
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(port));
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Chat server started on port " + port);

        while (true) {
   
            // 轮询准备就绪的事件
            selector.select();
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();

            while (keyIterator.hasNext()) {
   
                SelectionKey key = keyIterator.next();
                keyIterator.remove();

                if (key.isAcceptable()) {
   
                    handleAccept();
                } else if (key.isReadable()) {
   
                    handleRead(key);
                }
            }
        }
    }

    // 处理新客户端连接
    private void handleAccept() throws IOException {
   
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);

        String clientAddress = clientChannel.getRemoteAddress().toString();
        clientNames.put(clientChannel, clientAddress);
        System.out.println("Connected: " + clientAddress);

        broadcast("User " + clientAddress + " joined the chat", clientChannel);
    }

    // 读取客户端消息并广播给其他客户端
    private void handleRead(SelectionKey key) throws IOException {
   
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(256);
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead == -1) {
   
            // 客户端断开连接
            String clientName = clientNames.get(clientChannel);
            System.out.println("Disconnected: " + clientName);
            clientNames.remove(clientChannel);
            key.cancel();
            clientChannel.close();
            broadcast("User " + clientName + " left the chat", clientChannel);
            return;
        }

        buffer.flip();
        String message = new String(buffer.array(), 0, bytesRead);
        System.out.println(clientNames.get(clientChannel) + ": " + message.trim());

        broadcast(clientNames.get(clientChannel) + ": " + message, clientChannel);
    }

    // 向所有客户端广播消息
    private void broadcast(String message, SocketChannel sender) throws IOException {
   
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());

        for (SelectionKey key : selector.keys()) {
   
            Channel targetChannel = key.channel();

            if (targetChannel instanceof SocketChannel && targetChannel != sender) {
   
                SocketChannel clientChannel = (SocketChannel) targetChannel;
                clientChannel.write(buffer.duplicate());
            }
        }
    }

    public static void main(String[] args) throws IOException {
   
        int port = 123456;
        new WGNioChatServer(port).start();
    }
}

代码说明

  1. 初始化服务器：

    • 使用 ServerSocketChannel.open() 创建服务器套接字通道，配置为非阻塞模式，并绑定端口。
    • 使用 Selector.open() 创建选择器并将 ServerSocketChannel 注册到 Selector 上，监听连接事件 SelectionKey.OP_ACCEPT。

  2. 事件处理：

    • selector.select() 会阻塞直到至少一个通道变为就绪状态。
    • key.isAcceptable()：处理新的客户端连接，将新客户端通道注册到选择器中，监听读取事件 SelectionKey.OP_READ。
    • key.isReadable()：读取来自客户端的消息并广播给所有其他客户端。

  3. 广播机制：

    • 使用 Selector.keys() 遍历所有注册的通道（包含当前连接的所有客户端），将消息写入除发送者之外的所有客户端通道。

业务场景扩展

在实际业务中，可以进一步优化或扩展这个代码，比如：

  • 增加心跳检测来处理空闲客户端连接，避免资源浪费。
  • 将每个 SocketChannel 放到单独的线程池中处理，以实现更精细的并发控制。
  • 实现消息格式协议（如 JSON 或 Protobuf）来传输结构化数据。

6. 优化一下

在实际业务场景中，我们可以基于 Java NIO 对该聊天服务器进行如下优化：

  1. 心跳检测：定期检测客户端连接是否空闲，断开长时间无响应的连接，以节省资源。
  2. 线程池处理：将每个 SocketChannel 的消息处理放入线程池，以避免阻塞主线程，提高并发性能。
  3. 消息协议格式：使用 JSON 格式封装消息内容，使客户端与服务端之间的消息更加结构化。

下面是优化后的代码实现：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.*;
import java.util.concurrent.*;
import com.fasterxml.jackson.databind.ObjectMapper;

public class EnhancedNioChatServer {
   
    private final int port;
    private Selector selector;  // 多路复用器，负责管理多个通道
    private ServerSocketChannel serverSocketChannel;  // 服务器通道，用于监听客户端连接
    private final Map<SocketChannel, String> clientNames = new HashMap<>();  // 存储客户端名称
    private final Map<SocketChannel, Long> lastActiveTime = new ConcurrentHashMap<>();  // 存储客户端最后活动时间
    private final ScheduledExecutorService heartbeatScheduler = Executors.newScheduledThreadPool(1);  // 心跳检测定时任务
    private final ExecutorService workerPool = Executors.newFixedThreadPool(10);  // 处理客户端请求的线程池
    private final ObjectMapper objectMapper = new ObjectMapper();  // 用于 JSON 序列化的对象

    public EnhancedNioChatServer(int port) {
   
        this.port = port;
    }

    public void start() throws IOException {
   
        // 初始化服务器通道和选择器
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);  // 配置非阻塞模式
        serverSocketChannel.bind(new InetSocketAddress(port));  // 绑定端口
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  // 注册连接接收事件

        System.out.println("Chat server started on port " + port);

        // 启动心跳检测任务
        startHeartbeatCheck();

        while (true) {
   
            selector.select();  // 阻塞直到至少有一个事件发生
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();

            while (keyIterator.hasNext()) {
   
                SelectionKey key = keyIterator.next();
                keyIterator.remove();  // 防止重复处理

                if (key.isAcceptable()) {
   
                    handleAccept();  // 处理客户端连接
                } else if (key.isReadable()) {
   
                    handleRead(key);  // 处理客户端的消息读取
                }
            }
        }
    }

    // 处理新的客户端连接
    private void handleAccept() throws IOException {
   
        SocketChannel clientChannel = serverSocketChannel.accept();  // 接受新的客户端连接
        clientChannel.configureBlocking(false);  // 设置非阻塞模式
        clientChannel.register(selector, SelectionKey.OP_READ);  // 注册读事件

        String clientAddress = clientChannel.getRemoteAddress().toString();
        clientNames.put(clientChannel, clientAddress);  // 保存客户端地址
        lastActiveTime.put(clientChannel, System.currentTimeMillis());  // 记录最后活动时间

        System.out.println("Connected: " + clientAddress);
        broadcast(new Message("System", "User " + clientAddress + " joined the chat"), clientChannel);
    }

    // 处理读取客户端消息
    private void handleRead(SelectionKey key) {
   
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(256);  // 缓冲区用于读取客户端数据

        // 使用线程池处理，以免阻塞主线程
        workerPool.submit(() -> {
   
            try {
   
                int bytesRead = clientChannel.read(buffer);  // 读取客户端数据
                if (bytesRead == -1) {
   
                    disconnect(clientChannel);  // 客户端关闭连接
                    return;
                }
                lastActiveTime.put(clientChannel, System.currentTimeMillis());  // 更新最后活动时间
                buffer.flip();  // 准备读取缓冲区内容

                String messageContent = new String(buffer.array(), 0, bytesRead).trim();
                Message message = new Message(clientNames.get(clientChannel), messageContent);
                System.out.println(message.getSender() + ": " + message.getContent());

                broadcast(message, clientChannel);  // 广播消息给其他客户端
            } catch (IOException e) {
   
                disconnect(clientChannel);  // 处理异常情况下的客户端断开
            }
        });
    }

    // 处理客户端断开连接
    private void disconnect(SocketChannel clientChannel) {
   
        try {
   
            String clientName = clientNames.get(clientChannel);
            System.out.println("Disconnected: " + clientName);
            clientNames.remove(clientChannel);  // 移除客户端信息
            lastActiveTime.remove(clientChannel);  // 移除最后活动时间
            clientChannel.close();  // 关闭连接
            broadcast(new Message("System", "User " + clientName + " left the chat"), clientChannel);
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }

    // 广播消息给所有连接的客户端（除了消息发送者）
    private void broadcast(Message message, SocketChannel sender) {
   
        ByteBuffer buffer;
        try {
   
            buffer = ByteBuffer.wrap(objectMapper.writeValueAsBytes(message));  // 将消息序列化为 JSON
        } catch (IOException e) {
   
            e.printStackTrace();
            return;
        }

        for (SelectionKey key : selector.keys()) {
   
            Channel targetChannel = key.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != sender) {
     // 排除发送者
                SocketChannel clientChannel = (SocketChannel) targetChannel;
                try {
   
                    clientChannel.write(buffer.duplicate());  // 写入消息
                } catch (IOException e) {
   
                    disconnect(clientChannel);  // 处理写入失败的情况
                }
            }
        }
    }

    // 定期检查客户端是否超时未响应，超时则断开连接
    private void startHeartbeatCheck() {
   
        heartbeatScheduler.scheduleAtFixedRate(() -> {
   
            long currentTime = System.currentTimeMillis();
            for (SocketChannel clientChannel : lastActiveTime.keySet()) {
   
                long lastActive = lastActiveTime.get(clientChannel);
                if (currentTime - lastActive > 60000) {
     // 如果超时 1 分钟
                    System.out.println("Client timeout: " + clientNames.get(clientChannel));
                    disconnect(clientChannel);  // 断开超时客户端
                }
            }
        }, 10, 30, TimeUnit.SECONDS);  // 每隔 30 秒执行一次
    }

    public static void main(String[] args) throws IOException {
   
        int port = 123456;  // 定义端口号
        new EnhancedNioChatServer(port).start();  // 启动服务器
    }

    // 用于封装消息的内部类
    private static class Message {
   
        private String sender;
        private String content;

        public Message(String sender, String content) {
   
            this.sender = sender;
            this.content = content;
        }

        public String getSender() {
   
            return sender;
        }

        public String getContent() {
   
            return content;
        }
    }
}

解释一下

  1. selector 和 serverSocketChannel：负责管理通道事件和连接。
  2. clientNames 和 lastActiveTime：用于存储客户端信息，确保记录和维护连接状态。
  3. heartbeatScheduler：定时执行心跳检测任务，定期检查每个客户端的活动状态，断开超时连接。
  4. workerPool：线程池用于异步处理每个客户端的消息读取操作。
  5. 消息广播和心跳检测：使用 JSON 格式消息封装，消息广播会将消息发送给除发送者以外的所有客户端。

优化说明

  1. 心跳检测：

    • 使用 ScheduledExecutorService 每隔 30 秒检查一次所有客户端的最后活跃时间，如果某客户端超过 1 分钟未发送消息，则认为其超时，断开连接。

  2. 线程池处理读事件：

    • handleRead 方法中的 I/O 操作被提交到 workerPool 线程池，避免阻塞主线程，实现并发处理。这样即使某个客户端 I/O 操作较慢，服务器也能及时处理其他客户端的请求。

  3. 使用 JSON 协议封装消息：

    • 使用 Jackson ObjectMapper 将消息对象 Message 转换为 JSON 字符串，并进行发送和接收，这样消息内容更加结构化，客户端可以通过 JSON 协议轻松解析消息内容。

代码执行流程

  1. 启动服务器：初始化服务器和选择器，启动心跳检测任务。
  2. 连接和广播：每当有新客户端连接时，注册为读事件，并广播加入消息。读事件被分配到线程池中处理，消息被 JSON 序列化后广播到其他客户端。
  3. 心跳检测：定期检查客户端是否超时，断开长时间无响应的客户端。
  4. 断开连接：客户端断开连接或超时后，释放相关资源并广播退出消息。

这种优化使得服务器在高并发场景下更加健壮、灵活，并支持更精确的消息协议。

小结一下

epoll的高效性主要得益于两点：

  • 通过红黑树管理事件，实现事件的快速增删查改操作。
  • 使用就绪队列将活跃事件和非活跃事件分离，大幅减少不必要的系统调用。

好了，关于 epoll 多路复用你学会了吗，原创不易，感谢支持，关注威哥爱编程，编程路上 V 哥与你一路同行。

文章标签：
Java
Linux
数据格式
JSON
存储
威哥爱编程
目录
相关文章
弹性计算-百晓生
|
3天前
|
弹性计算 双11 开发者
阿里云ECS“99套餐”再升级！双11一站式满足全年算力需求
11月1日，阿里云弹性计算ECS双11活动全面开启，在延续火爆的云服务器“99套餐”外，CPU、GPU及容器等算力产品均迎来了全年最低价。同时，阿里云全新推出简捷版控制台ECS Lite及专属宝塔面板，大幅降低企业和开发者使用ECS云服务器门槛。
弹性计算-百晓生
87631 10
弹性计算-百晓生
|
21天前
|
存储 弹性计算 人工智能
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
阿里云弹性计算产品线、存储产品线产品负责人Alex Chen（陈起鲲）及团队内多位专家，和中国电子技术标准化研究院云计算标准负责人陈行、北京望石智慧科技有限公司首席架构师王晓满两位嘉宾，一同带来了题为《通用计算新品发布与行业实践》的专场Session。本次专场内容包括阿里云弹性计算全新发布的产品家族、阿里云第 9 代 ECS 企业级实例、CIPU 2.0技术解读、E-HPC+超算融合、倚天云原生算力解析等内容，并发布了国内首个云超算国家标准。
弹性计算-百晓生
101030 9
阿里云弹性计算_通用计算专场精华概览 | 2024云栖大会回顾
周周的奇妙编程
|
3天前
|
人工智能 弹性计算 文字识别
基于阿里云文档智能和RAG快速构建企业"第二大脑"
在数字化转型的背景下，企业面临海量文档管理的挑战。传统的文档管理方式效率低下，难以满足业务需求。阿里云推出的文档智能（Document Mind）与检索增强生成（RAG）技术，通过自动化解析和智能检索，极大地提升了文档管理的效率和信息利用的价值。本文介绍了如何利用阿里云的解决方案，快速构建企业专属的“第二大脑”，助力企业在竞争中占据优势。
周周的奇妙编程
4908 4
周周的奇妙编程
|
1天前
|
人工智能 自然语言处理 安全
创新不设限，灵码赋新能：通义灵码新功能深度评测
自从2023年通义灵码发布以来，这款基于阿里云通义大模型的AI编码助手迅速成为开发者心中的“明星产品”。它不仅为个人开发者提供强大支持，还帮助企业团队提升研发效率，推动软件开发行业的创新发展。本文将深入探讨通义灵码最新版本的三大新功能：@workspace、@terminal 和 #team docs，分享这些功能如何在实际工作中提高效率的具体案例。
周周的奇妙编程
2858 8
沃通WoTrus
|
7天前
|
负载均衡 算法 网络安全
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
阿里云平台WoSign品牌SSL证书是由阿里云合作伙伴沃通CA提供，上线阿里云平台以来，成为阿里云平台热销的国产品牌证书产品，用户在阿里云平台https://www.aliyun.com/product/cas 可直接下单购买WoSign SSL证书，快捷部署到阿里云产品中。
沃通WoTrus
1850 6
阿里云WoSign SSL证书申请指南_沃通SSL技术文档
沃通WoTrus
|
10天前
|
Web App开发 算法 安全
什么是阿里云WoSign SSL证书？_沃通SSL技术文档
WoSign品牌SSL证书由阿里云平台SSL证书合作伙伴沃通CA提供，上线阿里云平台以来，成为阿里云平台热销的国产品牌证书产品。
沃通WoTrus
1789 2
石臻臻的杂货铺
|
19天前
|
编解码 Java 程序员
写代码还有专业的编程显示器？
写代码已经十个年头了, 一直都是习惯直接用一台Mac电脑写代码 偶尔接一个显示器, 但是可能因为公司配的显示器不怎么样, 还要接转接头 搞得桌面杂乱无章，分辨率也低，感觉屏幕还是Mac自带的看着舒服
石臻臻的杂货铺
3783 12
云大宝
|
26天前
|
存储 人工智能 缓存
AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片
本案例介绍如何利用AI助理快速实现OSS存储的图片接入CDN，以加速图片访问。通过AI助理提炼关键操作步骤，避免在复杂文档中寻找解决方案。主要步骤包括开通CDN、添加加速域名、配置CNAME等。实测显示，接入CDN后图片加载时间显著缩短，验证了加速效果。此方法大幅提高了操作效率，降低了学习成本。
云大宝
5387 15
探索云世界
|
13天前
|
人工智能 关系型数据库 Serverless
1024，致开发者们——希望和你一起用技术人独有的方式，庆祝你的主场
阿里云开发者社区推出“1024·云上见”程序员节专题活动，包括云上实操、开发者测评和征文三个分会场，提供14个实操活动、3个解决方案、3 个产品方案的测评及征文比赛，旨在帮助开发者提升技能、分享经验，共筑技术梦想。
探索云世界
1142 152
绿水长流*z
|
21天前
|
存储 缓存 关系型数据库
MySQL事务日志-Redo Log工作原理分析
事务的隔离性和原子性分别通过锁和事务日志实现，而持久性则依赖于事务日志中的`Redo Log`。在MySQL中，`Redo Log`确保已提交事务的数据能持久保存，即使系统崩溃也能通过重做日志恢复数据。其工作原理是记录数据在内存中的更改，待事务提交时写入磁盘。此外，`Redo Log`采用简单的物理日志格式和高效的顺序IO，确保快速提交。通过不同的落盘策略，可在性能和安全性之间做出权衡。
绿水长流*z
1585 14