Java队列简介

在现代应用程序开发中，队列是一种常见且强大的数据结构，用于存储和管理待处理的任务序列。结合MySQL数据库，我们可以利用队列实现任务的持久化存储与高效处理。本文将通过四个案例，详细介绍如何在Java中使用队列，并结合MySQL数据库实现数据的存储与检索，涵盖基础队列操作、消息队列、延迟队列以及优先级队列的应用场景。

#### 环境准备

- Java开发环境：确保已安装JDK 8及以上版本。
- MySQL数据库：安装并运行MySQL服务，创建测试数据库。
- 依赖管理：使用Maven或Gradle管理项目依赖，引入JDBC驱动（如mysql-connector-java）。

表结构。

### 1. 基础队列表（queue）

```sql

CREATE TABLE `queue` (
    `id` INT AUTO_INCREMENT PRIMARY KEY,
    `item` VARCHAR(255) NOT NULL
);

```

### 2. 消息队列表（假设与基础队列共用，故无需额外创建）

### 3. 延迟队列表（delayed_queue）

```sql
CREATE TABLE `delayed_queue` (
    `id` INT AUTO_INCREMENT PRIMARY KEY,
    `task` VARCHAR(255) NOT NULL,
    `execute_at` TIMESTAMP NOT NULL
);

```

### 4. 优先级队列表（priority_queue）

```sql

CREATE TABLE `priority_queue` (
    `id` INT AUTO_INCREMENT PRIMARY KEY,
    `task` VARCHAR(255) NOT NULL,
    `priority` INT NOT NULL
);

```

请根据实际需求调整字段长度（如VARCHAR长度）和其他约束条件。在实际部署前，确保这些表结构符合你的应用逻辑和数据库设计规范。

#### 1. 基础队列实现

首先，创建一个简单的队列类`MySQLQueue`，用于模拟队列的基本操作，包括入队（enqueue）、出队（dequeue）。```java

import java.sql.*;

public class MySQLQueue {
    private Connection conn;
    
    public MySQLQueue(String url, String user, String password) throws SQLException {
        conn = DriverManager.getConnection(url, user, password);
    }
    
    public void enqueue(String item) {
        try (PreparedStatement pstmt = conn.prepareStatement("INSERT INTO queue (item) VALUES (?)")) {
            pstmt.setString(1, item);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public String dequeue() {
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT item FROM queue LIMIT 1")) {
            if (rs.next()) {
                String item = rs.getString("item");
                deleteFirstItem();
                return item;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    private void deleteFirstItem() throws SQLException {
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate("DELETE FROM queue LIMIT 1");
        }
    }
}

```

#### 2. 消息队列案例

在此案例中，我们将实现一个简单消息队列系统，用于异步处理日志记录。

```java

public class MessageQueue {
    // 使用MySQLQueue实现
    private final MySQLQueue queue;
    
    public MessageQueue(String url, String user, String password) throws SQLException {
        queue = new MySQLQueue(url, user, password);
    }
    
    public void logMessage(String message) {
        queue.enqueue(message);
        System.out.println("消息已入队：" + message);
    }
    
    public void processMessages() {
        while (true) {
            String message = queue.dequeue();
            if (message == null) break;
            System.out.println("处理消息：" + message);
            // 这里可以添加实际的处理逻辑
        }
    }
}

```

#### 3. 延迟队列

实现一个支持延迟处理的队列，通过在MySQL中存储任务及其执行时间，定时检查并执行到期任务。

```java

public class DelayedQueue {
    // ...省略连接初始化...
    
    public void scheduleTask(String task, long executeAtTimestamp) {
        try (PreparedStatement pstmt = conn.prepareStatement("INSERT INTO delayed_queue (task, execute_at) VALUES (?, ?)")) {
            pstmt.setString(1, task);
            pstmt.setTimestamp(2, new Timestamp(executeAtTimestamp));
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public void checkAndExecuteTasks() {
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT task FROM delayed_queue WHERE execute_at <= NOW()")) {
            while (rs.next()) {
                String task = rs.getString("task");
                System.out.println("执行延迟任务：" + task);
                // 执行任务逻辑
                deleteExecutedTask(task);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    private void deleteExecutedTask(String task) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement("DELETE FROM delayed_queue WHERE task = ?")) {
            pstmt.setString(1, task);
            pstmt.executeUpdate();
        }
    }
}

```

#### 4. 优先级队列

创建一个优先级队列，根据任务的优先级排序执行。

```java

public class PriorityQueue {
    // ...省略连接初始化...
    
    public void enqueueWithPriority(String task, int priority) {
        try (PreparedStatement pstmt = conn.prepareStatement("INSERT INTO priority_queue (task, priority) VALUES (?, ?)")) {
            pstmt.setString(1, task);
            pstmt.setInt(2, priority);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public void processPrioritizedTasks() {
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT task FROM priority_queue ORDER BY priority DESC")) {
            while (rs.next()) {
                String task = rs.getString("task");
                System.out.println("执行优先级任务：" + task);
                // 执行任务逻辑
                deleteExecutedTask(task);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    // ...省略deleteExecutedTask方法...
}

```

#### 总结

通过以上案例，我们不仅了解了如何在Java中使用队列数据结构，还学习了如何结合MySQL数据库实现队列的持久化存储与高效处理。无论是基础队列操作、消息队列的异步处理、延迟队列的定时任务调度，还是优先级队列的按优先级执行，这些案例均展示了队列在实际开发中的广泛应用和灵活性。请注意，为了简化示例，代码中未包含完整的错误处理和资源管理细节，在生产环境中务必确保资源的妥善管理和异常处理。