如何在900ms时限内处理刷卡机到Android的串行数据

问题分析 #

当前解析耗时4秒的核心诱因大概率是这几点：

• 分块接收时频繁创建字节数组导致GC开销过大
• ACK校验、分块累加的逻辑未做实时处理，存在不必要的等待
• CRC校验实现效率低下，未利用预计算表优化
• 可能存在不合理的线程阻塞或锁范围过大

具体优化方案 #

1. 高效管理接收缓冲区 #

用预分配的全局缓冲区替代每次创建新数组，减少内存分配与回收的耗时：

// 初始化足够大小的缓冲区（根据设备最大响应长度调整）
private final ByteArrayOutputStream responseBuffer = new ByteArrayOutputStream(1024);
private boolean isAckReceived = false;
private boolean isResponseComplete = false;

@Override
public void onNewData(byte[] data) {
    // 缩小同步范围，仅在操作缓冲区时加锁
    synchronized (responseBuffer) {
        try {
            responseBuffer.write(data);
            // 实时处理缓冲区数据，不等待后续分块
            processBuffer();
        } catch (IOException e) {
            // 简化异常处理，避免额外耗时
            e.printStackTrace();
        }
    }
}

2. 实时校验ACK并清理缓冲区 #

一旦检测到0x06 0x01立即标记ACK已接收，并移除缓冲区中的ACK数据，避免干扰后续响应解析：

private void processBuffer() {
    byte[] buffer = responseBuffer.toByteArray();
    int bufferLen = buffer.length;

    // 仅未收到ACK时执行检测逻辑
    if (!isAckReceived && bufferLen >= 2) {
        if (buffer[0] == 0x06 && buffer[1] == 0x01) {
            isAckReceived = true;
            // 重置缓冲区，保留可能已到达的后续响应数据
            responseBuffer.reset();
            if (bufferLen > 2) {
                responseBuffer.write(buffer, 2, bufferLen - 2);
            }
            return;
        }
    }

    // 处理完整响应块（0x02开头、0x03结尾）
    if (isAckReceived && !isResponseComplete) {
        int startIdx = -1;
        int endIdx = -1;
        // 快速定位起始与结束标记
        for (int i = 0; i < bufferLen; i++) {
            if (buffer[i] == 0x02) startIdx = i;
            else if (buffer[i] == 0x03 && startIdx != -1) {
                endIdx = i;
                break;
            }
        }

        // 确保包含完整CRC字段（0x03后两位）
        if (startIdx != -1 && endIdx != -1 && endIdx + 2 <= bufferLen) {
            byte[] fullResponse = Arrays.copyOfRange(buffer, startIdx, endIdx + 3);
            if (validateCrc(fullResponse)) {
                isResponseComplete = true;
                // 触发业务数据处理逻辑
                onValidResponseReceived(fullResponse);
            }
            // 重置缓冲区，准备下一次请求
            responseBuffer.reset();
        }
    }
}

3. 预计算CRC表优化校验速度 #

针对设备使用的CRC算法（示例为CRC-16）预计算校验表，将每字节的CRC计算复杂度从O(n)降至O(1)：

// 预计算CRC-16表，仅初始化一次
private static final int[] CRC_TABLE = new int[256];
static {
    for (int i = 0; i < 256; i++) {
        int crc = i;
        for (int j = 0; j < 8; j++) {
            crc = (crc >>> 1) ^ ((crc & 1) != 0 ? 0xA001 : 0);
        }
        CRC_TABLE[i] = crc;
    }
}

private boolean validateCrc(byte[] data) {
    if (data.length < 5) return false;
    int crc = 0xFFFF;
    // 计算从0x02到0x03的CRC值
    for (int i = 0; i <= data.length - 3; i++) {
        crc = (crc >>> 8) ^ CRC_TABLE[(crc & 0xFF) ^ (data[i] & 0xFF)];
    }
    // 读取响应中的CRC（注意字节序需与设备匹配）
    int receivedCrc = ((data[data.length - 2] & 0xFF) << 8) | (data[data.length - 1] & 0xFF);
    return crc == receivedCrc;
}

4. 精准控制超时逻辑 #

用ScheduledExecutorService实现900ms超时，避免阻塞串口线程：

private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
private Future<?> timeoutFuture;

// 发送请求时启动超时任务
public void sendRequest(byte[] request) {
    // 重置解析状态
    isAckReceived = false;
    isResponseComplete = false;
    responseBuffer.reset();
    // 启动900ms超时任务
    timeoutFuture = scheduler.schedule(() -> {
        synchronized (responseBuffer) {
            isResponseComplete = true;
            responseBuffer.reset();
            // 触发超时回调
            onResponseTimeout();
        }
    }, 900, TimeUnit.MILLISECONDS);
    // 发送请求到串口
    serialPort.write(request);
}

// 解析完成后取消超时任务
private void onValidResponseReceived(byte[] data) {
    if (timeoutFuture != null && !timeoutFuture.isCancelled()) {
        timeoutFuture.cancel(true);
    }
}

5. 减少冗余操作 #

• 移除onNewData中不必要的日志、UI操作或异常堆栈打印，这些都会增加耗时
• 确认串口配置（波特率、数据位、停止位、奇偶校验）与设备完全匹配，错误配置会导致传输慢或丢包

验证方法 #

用System.nanoTime()分别记录ACK检测、分块累加、CRC校验三个步骤的耗时，定位剩余瓶颈；同时测试极端场景（分块数量最多的响应），确保整体耗时控制在900ms内。

内容的提问来源于stack exchange，提问作者abhinav P