手撸一个java消息队列(二)

要实现一个线程安全且具有持久化功能的消息队列，我们可以使用Java的 BlockingQueue 接口以及它的实现类，如 LinkedBlockingQueue 。同时，为了实现持久化，我们可以将消息存储到文件系统或者使用数据库。以下是一个简单的例子，展示如何结合线程安全队列和文件系统来实现消息的持久化。
线程安全的消息队列类
首先，我们使用 LinkedBlockingQueue 来实现一个线程安全的消息队列：
java
复制
import java.util.concurrent.LinkedBlockingQueue;
import java.io.*;

public class PersistentQueue {
private LinkedBlockingQueue queue;
private String filePath;

public PersistentQueue(String filePath) {
    this.filePath = filePath;
    this.queue = new LinkedBlockingQueue<>();
    try {
        // 从文件中恢复消息
        recoverMessages();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// 将消息添加到队列，并写入到文件
public void enqueue(String message) throws IOException {
    queue.offer(message);
    writeToFile(message);
}

// 从队列中取出消息
public String dequeue() {
    return queue.poll();
}

// 从文件中恢复消息
private void recoverMessages() throws IOException {
    File file = new File(filePath);
    if (file.exists()) {
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            while ((line = reader.readLine()) != null) {
                queue.offer(line);
            }
        }
    }
}

// 将消息写入到文件
private void writeToFile(String message) throws IOException {
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
        writer.write(message);
        writer.newLine();
    }
}

}
生产者和消费者示例
接下来，我们定义生产者和消费者，它们将使用上面创建的 PersistentQueue 类：
java
复制
public class Producer implements Runnable {
private PersistentQueue queue;

public Producer(PersistentQueue queue) {
    this.queue = queue;
}

@Override
public void run() {
    try {
        for (int i = 0; i < 10; i++) {
            String message = "Message " + (i + 1);
            System.out.println("Produced: " + message);
            queue.enqueue(message);
            Thread.sleep(1000);
        }
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

}

public class Consumer implements Runnable {
private PersistentQueue queue;

public Consumer(PersistentQueue queue) {
    this.queue = queue;
}

@Override
public void run() {
    while (true) {
        String message = queue.dequeue();
        if (message != null) {
            System.out.println("Consumed: " + message);
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}

public class Main {
public static void main(String[] args) {
String filePath = “messages.txt”; // 消息存储文件的路径
PersistentQueue queue = new PersistentQueue(filePath);

    Producer producer = new Producer(queue);
    Consumer consumer = new Consumer(queue);

    new Thread(producer).start();
    new Thread(consumer).start();
}

}
这个例子中， PersistentQueue 类负责消息的存储和恢复。 enqueue 方法将消息添加到队列，并将其写入到文件中以实现持久化。 dequeue 方法从队列中取出消息。 recoverMessages 方法在队列实例化时从文件中恢复消息。
请注意，这只是一个简单的示例，实际应用中可能需要考虑更多的异常处理和性能优化措施。此外，根据 中提到的，如果需要更高级的持久化特性，可以考虑使用Redis等数据库系统，它们提供了RDB和AOF两种持久化方式，以确保数据的安全性和完整性。