Java 阻塞队列实现串口数据读取监听

串口通信

这里使用BlockingQueue阻塞队列的方式实现串口数据的读取监听

---

提示：Java 环境需使用1.6版本及一下的，否则会有出现内存 gc，等等异常问题。
RXTXcomm.jar 等ddl 文件下载【附带 配置教程】 ：https://yonxin.lanzoui.com/b010sfn3g
密码: gaw0

上代码

• 如图

代码如下：

package com.lance.serial.port;

import gnu.io.*;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 串口数据读取监听
 *
 * @author: Lance
 * @create: 2021-09-07 13:40
 * @version: 1.0
 */
public class SerialPortListenerManager extends Thread implements SerialPortEventListener {

    // 监听器,我的理解是独立开辟一个线程监听串口数据
    static CommPortIdentifier portId;       // 串口通信管理类
    static Enumeration<?> portList;         // 有效连接上的端口的枚举
    InputStream inputStream;                // 从串口来的输入流
    static OutputStream outputStream;       // 向串口输出的流
    static SerialPort serialPort;           // 串口的引用
    // 阻塞队列用来存放读到的数据
    private final BlockingQueue<String> queue = new LinkedBlockingQueue<>();
    // 格式化日期
    private final String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());

    /**
     * 持续监听端口上是否有数据流
     *
     * @param event 数据量
     */
    @Override
    public void serialEvent(SerialPortEvent event) {
        switch (event.getEventType()) {
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                break;
            case SerialPortEvent.DATA_AVAILABLE:// 当有可用数据时读取数据
                byte[] readBuffer = new byte[20];
                try {
                    String code;
                    int numBytes;
                    while (inputStream.available() > 0) {
                        numBytes = inputStream.read(readBuffer);
                        if (numBytes > 0) {
                            code = printHexString(readBuffer);
                            queue.add("日期：" + date + " - 真实收到的数据为：----->" + code);
                            readBuffer = new byte[20];// 重新构造缓冲对象，否则有可能会影响接下来接收的数据
                        } else {
                            queue.add("额------没有读到数据");
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;
        }
    }

    /**
     * bytes 字节数组转换 String
     *
     * @param bytes byte
     * @return code
     */
    public static String printHexString(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        for (byte value : bytes) {
            String hex = Integer.toHexString(value & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            // 每个字节由两个字符表示，位数不够，高位补 0
            builder.append(hex.toUpperCase());
        }
        String string = builder.toString();
        //截取A后面的0000000
        String substring = string.substring(0, string.indexOf("A"));
        return substring.concat("A");
    }

    /**
     * 通过程序打开串口，设置监听器以及相关的参数
     *
     * @return 返回1 表示端口打开成功，返回 0表示端口打开失败
     */
    public int startComPort() {
        // 通过串口通信管理类获得当前连接上的串口列表
        portList = CommPortIdentifier.getPortIdentifiers();
        while (portList.hasMoreElements()) {
            // 获取相应串口对象
            portId = (CommPortIdentifier) portList.nextElement();
            System.out.println("设备类型：-------> " + portId.getPortType());
            System.out.println("设备名称：-------> " + portId.getName());
            // 判断端口类型是否为串口
            if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                // 判断如果COM4串口存在，就打开该串口
                if (portId.getName().equals("COM4")) {
                    try {
                        // 打开串口名字为COM_4(名字任意),延迟为2毫秒
                        serialPort = (SerialPort) portId.open("COM4", 2000);
                    } catch (PortInUseException e) {
                        e.printStackTrace();
                        System.out.println("串口被占用或已经打开！！");
                        return 0;

                    }
                    // 设置当前串口的输入输出流
                    try {
                        inputStream = serialPort.getInputStream();
                        outputStream = serialPort.getOutputStream();
                    } catch (IOException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 给当前串口添加一个监听器
                    try {
                        serialPort.addEventListener(this);
                    } catch (TooManyListenersException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    // 设置监听器生效，即：当有数据时通知
                    serialPort.notifyOnDataAvailable(true);

                    // 设置串口的一些读写参数
                    try {
                        // 比特率、数据位、停止位、奇偶校验位
                        serialPort.setSerialPortParams(115200,
                                SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
                                SerialPort.PARITY_NONE);
                    } catch (UnsupportedCommOperationException e) {
                        e.printStackTrace();
                        return 0;
                    }
                    return 1;
                }
            }
        }
        return 0;
    }

    @Override
    public void run() {
         try {
            System.out.println("-------------------------任务处理线程运行了-------------------------");
            while (true) {
                // 如果堵塞队列中存在数据就将其输出
                if (queue.size() > 0) {
                    System.out.println(queue.take());
                }
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SerialPortListenerManager cRead = new SerialPortListenerManager();
        int i = cRead.startComPort();
        if (i == 1) {
            cRead.start();
            // 启动线程来处理收到的数据
            try {
                // 指令
                String code = "FE08010340270390FA";
                // 将指令转换成 byte 位 【这里可用枚举】
                byte[] parameter = {(byte) 0xFE, (byte) 0x08, (byte) 0x01, (byte) 0x03, (byte) 0x40, (byte) 0x27, (byte) 0x03, (byte) 0x90, (byte) 0xFA};

                System.out.println("发字节数：-------> " + parameter.length);
                outputStream.write(parameter, 0, parameter.length);
                outputStream.flush();
                outputStream.close();
                try {
                    // 发送完数据 阻塞1秒 防止读取不到数据
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {
            return;
        }
    }
}

---

总结

1、ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，FIFO（先进先出）。

2、LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue，静态工厂方法 Executors.newFixedThreadPool() 使用了这个队列。
3、SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法 Executors.newCachedThreadPool() 使用了这个队列。
4、PriorityBlockingQueue：一个具有优先级的无限阻塞队列。