从零手搓一个【消息队列】实现消息在文件中的存储

已于 2023-10-01 12:35:07 修改
阅读量578 收藏 1
点赞数
分类专栏： 消息队列项目 文章标签： 消息队列 序列化 文件 垃圾回收 GC
于 2023-10-01 00:52:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzhcjl_/article/details/133442682
版权

文章目录

创建 Spring Boot 项目, Spring Boot 2 系列版本, Java 8 , 引入 MyBatis, Lombok 依赖

提示：是正在努力进步的小菜鸟一只，如有大佬发现文章欠佳之处欢迎批评指点~ 废话不多说，直接上干货！

整体目录结构 :
在这里插入图片描述

本文主要实现 server 包

一、序列化 / 反序列化

在这里插入图片描述

Message 对象(或后续的网络请求需要的数据)需要转成⼆进制写⼊⽂件. 并且也需要把⽂件中的⼆进制读出来解析成对象. 此处针对这⾥的逻辑进⾏封装

  • 序列化: 对象 --> 二进制数据
  • 反序列化: 二进制数据 --> 对象

此处使用 Java 标准库提供的序列化 / 反序列化工具, 使⽤ ObjectInputStream 类 / ObjectOutputStream 类进⾏序列化 / 反序列化操作. 通过内部的 readObject / writeObject 即可完成对应操作


    // 序列化
    public static byte[] toByteArray(Object object) throws IOException {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            try (ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream)) {
                outputStream.writeObject(object);
            }
            return byteArrayOutputStream.toByteArray();
        }
    }

    // 反序列化
    public static Object toObject(byte[] array) throws IOException {
        Object object = null;
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(array)) {
            try (ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream)) {
                object = objectInputStream.readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return object;
    }

  • 使⽤ ByteArrayInputStream / ByteArrayOutputStream 针对 byte[] 进⾏封装, 相当于提供了一个变长字节数组, (序列化之前不知道这个对象转成字节数组之后有多长, 直接拿 ByteArrayOutputStream 接收即可 )

  • 这两个流对象是纯内存的, 不需要进⾏ close, 此处仍然套上了 try() 也没什么副作用, 养成好习惯~

  • readObject 和 writeObject 这两个方法表示"从哪读", “写到哪”, 取决于和哪个流对象关联, 此处是和 byteArrayOutputStream / byteArrayInputStream, 所以表示"从字节数组里读". “写到字节数组” , 如果和网络( socket 的 输入输出流) 关联, 那就是"从网卡里读", “写到网卡里”

补充说明, 有些序列化 / 反序列场景可以引入"serialVersionUID “, 表示"版本号”, 如下代码所示
public static final long serialVersionUID = 1L;
实际开发中, 代码可能会经常修改和调整, 比如今天定义好了 Message 类, 序列化后写入了文件, 过段时间有给这个类扩充了新功能, 然后再从文件中反序列化出来 message 对象, 大概率是错的, 即使程序不报错, 数据格式也会错乱
为了防止这种情况发生, 修改 Message 类后就把 serialVersionUID 手动更新, 这样再序列化 / 反序列化, 如果版本号不一致, 就会直接报错, 显式的提醒程序员, 而不是使用错乱的数据执行后续代码

二、文件存储设计

1, 队列目录

消息需要在硬盘上存储. 但是并不直接放到数据库中, ⽽是直接使⽤⽂件存储
原因如下:

  1. 对于消息的操作并不需要复杂的 增删改查
  2. 对于⽂件的操作效率⽐数据库会⾼很多

主流 MQ 的实现(包括 RabbitMQ), 都是把消息存储在⽂件中, ⽽不是数据库中

我们给每个队列分配⼀个⽬录. ⽬录的名字为 data + 队列名. 形如 ./data/testQueue
该⽬录中包含两个固定名字的⽂件.

  • queue_data.txt 消息数据⽂件, ⽤来保存消息内容
  • queue_stat.txt 消息统计⽂件, ⽤来保存消息统计信息
    在这里插入图片描述

服务器中可以有 N 个目录, 也就可以有 N 个 queue 目录

2, 消息数据文件

queue_data.txt ⽂件格式 : 使⽤⼆进制⽅式存储, 每个消息分成两个部分

  • 前四个字节, 表⽰ Message 对象的⻓度(字节数)
  • 后⾯若⼲字节, 表⽰ Message 内容

消息和消息之间⾸尾相连, 每个 Message 基于 Java 标准库的 ObjectInputStream / ObjectOutputStream 序列化

在这里插入图片描述

新增和删除消息时, 就需要知道文件中消息的位置, 上篇文章设计核心类的时候, Message 这个类中就给了两个成员属性表示 “偏移量”, 并且使用 transient 修饰, 不被序列化

    // 消息存储在文件中的偏移量(字节, 约定 "[,)" 区间 )
    private transient long offsetBegin = 0;
    private transient long offsetEnd = 0;

在这里插入图片描述

3, 消息统计文件

queue_stat.txt ⽂件格式: 使⽤⽂本⽅式存储
⽂件中只包含⼀⾏, ⾥⾯包含两列(都是整数), 使⽤ \t 分割
第⼀列表⽰当前总的消息数⽬. 第⼆列表⽰有效消息数⽬
形如: 100\t50

三、硬盘管理 – 文件

在这里插入图片描述

1, 创建 MessageFileManager 类

充分结合面向对象思想, 创建一个内部类 Stat 表示消息统计文件中, 定义两个成员属性 totalCount, validCount 表示消息总数和有效消息数

写出获取队列目录, 消息文件, 统计文件的路径

public class MessageFileManager {
    /**
     * 内部类 表示 queue_stat.txt 文件中需要的的字段
     */
     public static class Stat {
        public int totalCount; // 总消息数
        public int validCount; // 有效消息数
    }

    // 获取队列的存储目录
    private String getQueueDir(String queueName) {
        return "./data/" + queueName;
    }

    // 获取该队列的消息存储数据文件
    private String getQueueDataPath(String queueName) {
        return getQueueDir(queueName) + "/queue_data.txt";
    }

    // 获取该队列的消息存储统计文件
    private String getQueueStatPath(String queueName) {
        return getQueueDir(queueName) + "/queue_stat.txt";
    }
}

2, createQueueFiles() 创建目录/文件

创建文件之后别忘了在统计文件中初始化 totalCount 和 validCount

	public void createQueueFiles(String queueName) throws IOException {
        File queueDir = new File(getQueueDir(queueName));
        if (!queueDir.exists()) {
            boolean result1 = queueDir.mkdirs();
            if (!result1) {
                throw new IOException("[MessageFileManager.createQueueFiles()] 创建目录失败: " + 
                        queueDir.getAbsolutePath());
            }
        }
        File dataPath = new File(getQueueDataPath(queueName));
        if (!dataPath.exists()) {
            boolean result2 = dataPath.createNewFile();
            if (!result2) {
                throw new IOException("[MessageFileManager.createQueueFiles()] 创建data文件失败: " + 
                        dataPath.getAbsolutePath());
            }
        }
        File statPath = new File(getQueueStatPath(queueName));
        if (!statPath.exists()) {
            boolean result3 = statPath.createNewFile();
            if (!result3) {
                throw new IOException("[MessageFileManager.createQueueFiles()] 创建stat文件失败: " +
                        statPath.getAbsolutePath());
            }
        }
        // 给 stat.txt 文件中写入默认数据
        Stat stat = new Stat();
        stat.totalCount = 0;
        stat.validCount = 0;
        writeStat(queueName, stat);
    }

3, deleteFiles() 删除目录/文件

如果服务器要删除某个队列, 那么这个队列的消息的相关数据文件也要删除

File 类的 delete 方法只能删除空目录, 因此需要先把内部的闻件先删除掉先删除文件再删除目录

    public void deleteFiles(String queueName) throws IOException {
        File dataPath = new File(getQueueDataPath(queueName));
        boolean result1 = dataPath.delete();
        File statPath = new File(getQueueStatPath(queueName));
        boolean result2 = statPath.delete();
        File queueDir = new File(getQueueDir(queueName));
        boolean result3 = queueDir.delete();
        if (!(result1 && result2 && result3)) {
            throw new IOException("[MessageFileManager.deleteFiles()] 删除目录文件失败: " +
                    queueDir.getAbsolutePath());
        }
    }

4, checkFileExists() 检查目录/文件是否存在

判定该队列的消息⽂件和统计⽂件是否存在. ⼀旦出现缺失, 则不能进⾏后续⼯作

    public boolean checkFileExists(String queueName) {
        File queueDir = new File(getQueueDir(queueName));
        File dataPath = new File(getQueueDataPath(queueName));
        File statPath = new File(getQueueStatPath(queueName));
        return queueDir.exists() && dataPath.exists() && statPath.exists();
    }

5, readStat() 从 stat.txt 文件中读数据

	private Stat readStat(String queueName) {
        Stat stat = new Stat();
        try (InputStream inputStream = new FileInputStream(getQueueStatPath(queueName))) {
            Scanner scanner = new Scanner(inputStream);
            stat.totalCount = scanner.nextInt();
            stat.validCount = scanner.nextInt();
            return stat;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

6, writeStat() 从 stat.txt 文件中写数据

    private void writeStat(String queueName, Stat stat) {
        // 使用 PrintWrite 来写文件.
        try (OutputStream outputStream = new FileOutputStream(getQueueStatPath(queueName))) {
            PrintWriter writer = new PrintWriter(outputStream);
            writer.write(stat.totalCount + "\t" + stat.validCount);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

7, sendMessage() 发送消息

自定义一个异常类

public class MQException extends Exception {
    public MQException(String message) {
        super(message);
    }
}

这里的发送消息, 并不是把生产者把消息发送给服务器, 而是这个把消息写入到文件存储起来, 只是作为发送消息这个功能的背后的一环

最后别忘了更新 stat 统计文件中的数据

	public void sendMessage(MessageQueue queue, Message message) throws IOException, MQException {
        // 1, 检查目录和文件是否存在
        boolean result = checkFileExists(queue.getName());
        if (!result) {
            throw new MQException("[MessageFileManager.sendMessage()] queueName=" + queue.getName() + "的文件不存在");
        }
        // 2, 消息序列化
        byte[] messageBinary = BinaryUtil.toByteArray(message);
        synchronized (queue) {
            // 3, 设置消息在文件中的偏移量
            String dataPath = getQueueDataPath(queue.getName());
            File dataFile = new File(dataPath);
            message.setOffsetBegin(dataFile.length() + 4);
            message.setOffsetEnd(dataFile.length() + 4 + messageBinary.length);
            // 4, 写入文件
            try (OutputStream outputStream = new FileOutputStream(dataPath, true)) {
                try (DataOutputStream dataOutputStream = new DataOutputStream(outputStream)) {
                    dataOutputStream.writeInt(messageBinary.length); // 消息长度(4字节)
                    dataOutputStream.write(messageBinary); // 消息本体(messageBinary.length字节)
                }
            }
            // 5, 更新 stat.txt 文件中的数据
            Stat stat = readStat(queue.getName());
            stat.validCount += 1;
            stat.totalCount += 1;
            writeStat(queue.getName(), stat);
        }
    }
  • 考虑线程安全, 按照队列维度进⾏加锁
  • 使⽤ DataOutputStream 进⾏⼆进制写操作. ⽐原⽣ OutputStream 要⽅便
  • 需要记录 Message 对象在⽂件中的偏移量. 后续的删除操作依赖这个偏移量定位到消息. offsetBegin 是原有⽂件⼤⼩的基础上, 再 + 4, 4 个字节是存放消息⼤⼩的空间. (参考下图)
    在这里插入图片描述

8, deleteMessage() 删除消息

此处的删除只是 “逻辑删除”, 即把 Message 类中的 isValid 字段设置为 0.

	public void deleteMessage(MessageQueue queue, Message message) throws IOException {
        synchronized (queue) {
            // 1, 随机访问文件, 根据偏移量读出消息 (rw 表示打开方式, 可读也可写)
            try (RandomAccessFile randomAccessFile = new RandomAccessFile(getQueueDataPath(queue.getName()), "rw")) {
                // 2, 读取二进制消息
                byte[] messageBinaryFrom = new byte[(int) (message.getOffsetEnd() - message.getOffsetBegin())];
                randomAccessFile.seek(message.getOffsetBegin()); // 光标移动
                randomAccessFile.read(messageBinaryFrom);
                // 3, 二进制消息-->消息对象
                Message messageInFile = (Message) BinaryUtil.toObject(messageBinaryFrom);
                // 4, 修改isValid字段
                messageInFile.setIsValid((byte) 0x0);
                // 5, 消息对象-->二进制消息
                byte[] messageBinaryTo = BinaryUtil.toByteArray(messageInFile);
                // 6, 写入文件
                randomAccessFile.seek(message.getOffsetBegin()); // 光标移动
                randomAccessFile.write(messageBinaryTo);
            }
            // 5, 更新 stat.txt 文件中的数据
            Stat stat = readStat(queue.getName());
            stat.validCount -= 1;
            writeStat(queue.getName(), stat);
        }
    }
  • 同样使用 synchronized 针对队列加锁
  • 使⽤ RandomAccessFile 来随机访问到⽂件的内容
  • 根据 Message 中的 offsetBegin 和 offsetEnd 定位到消息在⽂件中的位置. 通过
    randomAccessFile.seek 操作⽂件指针(相当于鼠标光标)偏移过去. 再读取
  • 读出的结果解析成 Message 对象, 修改 isValid 字段, 再重新写回⽂件. 注意写的时候要重新设定⽂件指针(光标)的位置. ⽂件指针会随着上述的读操作产⽣改变
  • 最后, 要记得更新统计⽂件, 把合法消息 - 1

9, isNeedGC() 是否需要垃圾回收

此处我们自定义一个策略 : 当文件中消息总数超过 2k, 但有效消息不足 30% 触发垃圾回收

    public boolean isNeedGC(String queueName){
        Stat stat = readStat(queueName);
        return stat.totalCount > 2000 && (stat.validCount * 1.0 / stat.totalCount < 0.3);
    }

10, gc() 垃圾回收

之前的删除操作, 只是把消息在⽂件上标记成了⽆效. 并没有腾出硬盘空间. 最终⽂件⼤⼩可能会越积越多. 因此需要定期的进⾏批量清除, 此处参考使用 JVM 的复制算法
GC 的时候会把所有有效消息加载出来(后面介绍这个方法), 写⼊到⼀个新的消息⽂件中, 使⽤新⽂件, 代替旧⽂件即可

GC 的过程中不允许其他线程对该文件进行修改, 所以对整个方法加锁

	public void gc(MessageQueue queue) throws IOException, MQException {
        synchronized (queue) {
            String queueName = queue.getName();
            // 1, 记录开始执行时间
            long startGC = System.currentTimeMillis();
            // 2, 创建(临时的)new_queue_data.txt 文件
            File newDataFile = new File(getNewQueueDataPath(queueName));
            if (newDataFile.exists()) {
                throw new MQException("[MessageFileManager.gc()] new_queue_data.txt 文件已经存在, queueName = " + queueName);
            }
            boolean result1 = newDataFile.createNewFile();
            if (!result1) {
                throw new MQException("[MessageFileManager.gc()] new_queue_data.txt 文件创建失败, newDataFile = " + newDataFile.getAbsolutePath());
            }
            // 3, 读取 data.txt 文件中的所有有效消息
            LinkedList<Message> ValidMessages = loadAllMessageFromQueue(queueName);
            // 4, 把所有有效消息写入 new_queue_data.txt
            try (OutputStream outputStream = new FileOutputStream(getNewQueueDataPath(queueName))) {
                try (DataOutputStream dataOutputStream = new DataOutputStream(outputStream)) {
                    for (Message message : ValidMessages) {
                        // 消息对象-->二进制消息
                        byte[] messageTo = BinaryUtil.toByteArray(message);
                        dataOutputStream.writeInt(messageTo.length);
                        dataOutputStream.write(messageTo);
                    }
                }
            }
            // 5, 删除 data.txt, 重命名 new_queue_data.txt --> data.txt
            File dataFile = new File(getQueueDataPath(queueName));
            boolean result2 = dataFile.delete();
            if (!result2) {
                throw new MQException("[MessageFileManager.gc()] 删除 queue_data.txt 文件失败! dataFile = " + dataFile.getAbsolutePath());
            }
            boolean result3 = newDataFile.renameTo(dataFile);
            if (!result3) {
                throw new MQException("[MessageFileManager.gc()] 重命名 new_queue_data.txt 文件失败! newDataFile = " + newDataFile.getAbsolutePath());
            }
            // 6, 更新 stat.txt 文件
            Stat stat = readStat(queueName);
            stat.totalCount = ValidMessages.size();
            stat.validCount = ValidMessages.size();
            writeStat(queueName, stat);
            // 7, 记录结束时间
            long endGC = System.currentTimeMillis();
            System.out.println("[MessageFileManager.gc()] 执行时间: " + (endGC - startGC) + "ms");
        }
    }

11, loadAllMessageFromQueue() 加载所有有效消息

把消息内容从⽂件加载到内存中. 这个功能在服务器重启, 和垃圾回收的时候都很关键

	public LinkedList<Message> loadAllMessageFromQueue(String queueName) throws IOException, MQException {
        LinkedList<Message> messagesLinkedList = new LinkedList<>();
        try (InputStream inputStream = new FileInputStream(getQueueDataPath(queueName))){
            try (DataInputStream dataInputStream = new DataInputStream(inputStream)) { //这个流可以读取字节
                int currentOffsetBegin = 0;
                // 循环读取所有有效消息
                while (true) {
                    // 1, 读取消息长度
                    int messageLength = dataInputStream.readInt();
                    // 2, 读取消息内容
                    byte[] messageBinaryFrom = new byte[messageLength];
                    int messageActualLength = dataInputStream.read(messageBinaryFrom);
                    if (messageActualLength != messageLength) {
                        throw new MQException("[MessageFileManager.loadAllMessageFromQueue()] 读取消息时文件错乱, queueName = " + queueName);
                    }
                    // 3, 二进制消息-->消息对象
                    Message messageInFile = (Message) BinaryUtil.toObject(messageBinaryFrom);
                    // 4, 判断是否为有效消息
                    if (messageInFile.getIsValid() != 0x1) {
                        currentOffsetBegin += (4 + messageActualLength);
                        continue;
                    }
                    // 5, 由于偏移量没有序列化, 需要再消息对象中设置偏移量后再存入链表
                    messageInFile.setOffsetBegin(currentOffsetBegin + 4);
                    messageInFile.setOffsetEnd(currentOffsetBegin + 4 + messageActualLength);
                    messagesLinkedList.add(messageInFile);
                    currentOffsetBegin += 4 + messageActualLength;
                }
            } catch (EOFException e) {
                // 这个 catch 并非真是处理 "异常", 而是处理 "正常" 的业务逻辑. 文件读到末尾, 会被 readInt 抛出该异常.
                // 这个 catch 语句中也不需要做啥特殊的事情
                System.out.println("[MessageFileManager.loadAllMessageFromQueue()] 读取 Message 数据完成!");
            }
        }
        return messagesLinkedList;
    }
  • 使⽤ DataInputStream 读取数据. 先读 4 个字节为消息的⻓度, 然后再按照这个⻓度来读取实际消息内容.
  • 读取完毕之后, 转换成 Message 对象.
  • 同时计算出该对象的 offsetBegin 和 offsetEnd.
  • 最终把结果整理成链表, 返回出去.
  • 注意, 对于 DataInputStream 来说, 如果读取到 EOF, 会抛出⼀个 EOFException , ⽽不是返回特定值. 因此需要注意上述循环的结束条件, 抛出⼀个 EOFException 就会退出循环, 但对程序无影响

四、小结

本文主实现了两点:

  • 1, 实现了序列化 / 反序列化, 为了保证数据能在文件中存储以及后续的网络传输
  • 2, 持久化存储 --> 硬盘管理 --> 文件
    • 2.1, 设计了消息在文件中存储的格式和规范
    • 2.2, 设计了垃圾回收机制(复制算法), 防止垃圾数据持续堆积
    • 2.3, 编写了文件管理的基本操作: 关于文件和目录的创建 / 删除, 关于消息的添加 / 删除等

上篇文章 主要实现了硬盘上数据库的管理, 本篇主要实现了营盘山文件的管理, 所以下篇文章会对数据库和文件的进一步整合, 封装成对硬盘上数据的统一管理, 为上层(服务器)提供 API , 并且实现对内存中数据的管理

灵魂相契的树
关注
专栏目录
Java利用Redis实现消息队列的示例代码
08-29
* Redis中的list数据结构可以用于实现消息队列，通过lpush和rpop操作可以实现消息的存储和取出。 * Jedis是Redis的Java客户端，提供了连接Redis的功能，包括连接池设置和存储操作。 四、Java实现消息队列 * Java...
消息队列之 (4)-将消息写入到文件中
qq_56454895的博客
08-01 487
我们之前说过, 消息队列不管要往硬盘中存储, 还要往内存中存储, 并且是以内存为主 ,硬盘为辅, 接下来, 就将消息队列如何存储到硬盘 做一个设计我们往硬盘中存放的消息, 只是简单的 存 和 取 还有删除 , 并不涉及 复杂的增删改查, 而且消息的数量可能会非常多, 往数据库中存放效率不高我们之前说过, 消息 是 依附于队列来存在的, 所以存储的时候 就要按照队列的分类来存储 ,在一个虚拟主机中, 会有多个队列 , 每个队列下面, 放着一个文件, 文件中存储我们的消息, 那一个文件不可能只存储一个消息, 而
从零手搓一个【消息队列】实现虚拟主机的核心功能
yzhcjl_的博客
10-03 501
本篇主要实现了"虚拟主机", 类似于数据库, 虚拟主机的作用是为了隔离不同业务线的数据, 虚拟主机把硬盘(数据库+文件)和内存这两个模块的数据管理整合在一起, 并且封装了一系列核心 API, 供上层( BrokerServer )调用
rabbitmq详解
web15085599741的博客
08-02 861
RabbitMQ是一个实现了AMQP（AdvancedMessageQueuingProtocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。你可以把它想像成一个邮局你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。主要流程。...
手搓消息队列【RabbitMQ版】
hero_jy的博客
09-12 1912
阻塞队列（Blocking Queue）-> 生产者消费者模型 （是在一个进程内）所谓的消息队列，就是把阻塞队列这样的数据结构，单独提取成了一个程序，进行独立部署~ --------> 生产者消费模型 （进程和进程之间/服务和服务之间）解耦合本来有个分布式系统，A服务器 调用 B服务器（A给B发请求，B给A返回响应）===》 A 和 B 的耦合是比较大的！引入消息队列后，A把请求发送到消息队列，B再从消息队列获取到请求削峰填谷。
一文让你彻底理解关于消息队列的使用
嵌入式Linux内核的博客
02-25 1474
消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。
Python中线程的MQ消息队列实现以及消息队列的优点解析
09-21
在上述代码示例中，我们看到如何使用`threading`和`Queue`来创建一个简单的多线程消息队列。首先，创建了一个`Queue.Queue()`实例，这是线程安全的，可以被多个线程共享。然后，创建了`ThreadNum`类，它继承自`...
C++ 中消息队列函数实例详解
08-30
接收消息可以使用 `msgrcv` 函数，该函数可以从消息队列中接收一个消息。删除消息队列可以使用 `msgctl` 函数，该函数可以删除一个已经存在的消息队列。 示例程序 下面是一个使用 `msgget` 函数创建消息队列的示例...
Java中实现消息队列的策略与代码实践
最新发布
10-30
消息队列是分布式系统中不可或缺的组件，通过Java的并发包，我们可以轻松实现一个内存消息队列用于学习和测试。实际应用中，应根据具体需求选择合适的消息队列中间件，并结合业务场景进行优化和扩展。随着技术的发展...
从零手搓一个【消息队列】项目设计、需求分析、模块划分、目录结构
yzhcjl_的博客
09-29 504
可跨主机的生产者消费者服务器程序，用于服务器之间的解耦，流量削峰；使用RPC模式，由客户端发送网络请求，远程调用服务器以操作交换机、队列、发布消息、订阅消息等；由服务器实现相关逻辑、持久化存储、异步转发消息等
FIFO消息队列（内存、文件双缓冲模式）
freeland008的专栏
12-11 3848
 1          概述本文档适用于C语言开发人员，用于在开发过程中进行参考，文档详细讲述每个函数的用法以及源码示例。 2          支持文件缓存消息队列介绍一般的FIFO消息队列都是基于内存，即所有的消息都保存在内存中。但是在很多情况下，消息队列中的消息数目难以确定，可能超过系统内存的容量，导致传统的FIFO消息队列无法满足应用的需求，所以推出基于内存加磁盘文
RocketMQ源码系列(四) 消息store存储设计核心原理解析
Dream_it_possible！的博客
06-20 1391
一、发送消息 二、消息存储 rocketmq
从零手搓一个【消息队列】创建核心类, 数据库设计与实现
yzhcjl_的博客
09-30 833
充分结合面向对象思想, 创建出了交换机, 队列, 绑定, 消息, 等核心概念的类, 使用 SQLite, 并结合 MyBatis 编写了交换机, 队列, 绑定的建表, 增, 删, 查的 sql, 对数据库的初始化, 判断存在, 删除等做进一步的封装
hdjs-图片 文件上传
消息队列
09-12 1179
在写博客时需要上传修改头像和上传文件时，需要用到上传，用一套方法来控制图片和文件的上传 第一步：构建上传页面: &amp;amp;lt;form action=&amp;quot;{{route('member.user.updata',[auth()-&amp;amp;gt;user()])}}&amp;quot; method=&amp;quot;post&amp;quot;id=&amp;quot;updataImage&amp;q
【消息队列开发】 把消息写入文件
m0_71731682的博客
03-14 1120
本次开发任务 实现消息序列化与反序列化 把消息写入文件。
消息队列——RabbitMq
weixin_45080272的博客
05-28 5689
一、消息队列的使用场景 一、消息队列的使用场景) 一、消息队列的使用场景 异步处理 应用解耦 流量削锋 消息通讯 【1】异步处理：场景说明：用户注册后，需要发注册邮件和注册短信。 引入消息队列后架构如下：用户的响应时间=注册信息写入数据库的时间，例如50毫秒。发注册邮箱、发注册短信写入消息队列后，直接返回客户端，因写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。 按照传统的做法： ①、串行方式，将注册信息写入数据库成功后，发注册邮件，再发送注册短信，以上三个成功后，返回客户端。可
消息 队列
liubo0525
03-08 647
文章目录kafka 分布式消息队列ActiveMQRabbitMQRocketMQ 消息队列 MQ 全称message queue 数据的消费方式无非也就实时和离线两种方式；MQ最大的应用是在于实时数据的出来上。 队列这种东西，最广泛的作用还是在于解耦，宽泛一点的说，它可以将不同部门的工作内容进行有效的整合，基于一个约定好的格式，就可以两头互相不干扰的进行开发。可以说这个生产消费的思想不仅仅适用于程序也适用于非常多的地方。 kafka 分布式消息队列 http://www.cnblogs.com/likeh
在Linux环境下，使用消息队列实现客户端-服务器应用程序，完成文件传输功能。请详细编写程序...
weixin_42593130的博客
02-13 147
在Linux环境下，可以使用消息队列来实现客户端-服务器应用程序，完成文件传输功能。程序代码如下：// 服务器端： #include <stdio.h> #include <stdlib.h> #include <sys/msg.h> #define MAX_LEN 128 struct my_msgbuf { long mtype; char ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

灵魂相契的树

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

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

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

打赏作者

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

抵扣说明：

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

余额充值