包含null元素的Fifo缓冲区

Question

我有一个通过rs232与程序通信的设备。设备发送消息，程序逐字节读取并放入缓冲区，以便另一个线程解析缓冲区。问题是，在消息中，我将有一个0x00字节{fifo缓冲区的null元素}，所以我不能在fifo中输入该元素。如何解决这个问题。我使用

BlockingQueue<Byte> queue = new ArrayBlockingQueue<>(1000);

用于在fifo:中输入字节

public void serialEvent(jssc.SerialPortEvent event) {
  if (event.isRXCHAR()) {//If data is available
     try {
        buffer = serialPort.readBytes();
        System.out.println(bytesToHex(buffer) + " event");
        for (int i = 0; i < buffer.length; i++) {
        queue.add(buffer[i]);
        }
  } catch (SerialPortException ex) {
      System.out.println(ex);
  }

并且对于轮询元素

byte stx = queue.poll();

如何输入null元素，因为消息将有null字节？

解析代码（解析线程）：

public void run() {
            while (true) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.size() + " 1 proverka");
                    sb = new StringBuilder();
                    byte stx = queue.poll();
                    System.out.println(byteToHex(stx) + " parser");
                    if (stx == 0x02) {
                        sb.append(String.format("%02X ", stx));
                        System.out.println(queue.size() + " 2 proverka");
                        for (int i = 0; i < 3; i++) {
                            System.out.println(queue.size() + " 3 proverka " + i + " krug");
                            len[i] = queue.poll();
                            System.out.println(byteToHex(len[i]) + " parser");

输出：

02事件0000事件01事件4 1证明77事件2解析器03事件75事件6 2证明6 3证明0克鲁格线程"thread-1"java.lang.NullPointerException中出现异常位于e.moduli.ingenico_card_reader.ingenico_card_reader$SerialParser.run（ingenico_card_reader.java:127）

用我的自定义字节类编辑

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package es.moduli.ingenico_card_reader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import jssc.SerialPort;
import jssc.SerialPortEventListener;
import jssc.SerialPortException;
/**
 *
 * @author GiGo
 */
public class Ingenico_Card_Reader {
    static SerialPort serialPort;
    static BlockingQueue<CustomByte> queue = new ArrayBlockingQueue<>(1000);
    final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
    public void open() {
        serialPort = new SerialPort("COM4");
        try {
            serialPort.openPort();//Open port
            serialPort.setParams(9600, 8, 1, 0);//Set params
            int mask = SerialPort.MASK_RXCHAR;//Prepare mask
            serialPort.setEventsMask(mask);//Set mask
            serialPort.addEventListener(new SerialPortEvent());//Add SerialPortEventListener
        } catch (SerialPortException ex) {
            System.out.println(ex);
        }
        SerialParser parser = new SerialParser();
        parser.start();
    }
    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }
    public static String byteToHex(byte b) {
        int i = b & 0xFF;
        return Integer.toHexString(i);
    }
    public static int byteToIntBE(byte[] b) {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.BIG_ENDIAN);
        int result = bb.getInt();
        return result;
    }
    public static void sleep(long i) {
        try {
            Thread.sleep(i);
        } catch (Exception e) {
        }
    }
    public static String hexString(byte[] b) {
        StringBuilder d = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            char hi = Character.forDigit(b[i] >> 4 & 0xF, 16);
            char lo = Character.forDigit(b[i] & 0xF, 16);
            d.append(Character.toUpperCase(hi));
            d.append(Character.toUpperCase(lo));
        }
        return d.toString();
    }
    public static class SerialPortEvent implements SerialPortEventListener {
        byte buffer[];
        @Override
        public void serialEvent(jssc.SerialPortEvent event) {
            if (event.isRXCHAR()) {//If data is available
                //if (event.getEventValue() == 1) {//Check bytes count in the input buffer
                //Read data, if 1 byte available 
                try {
                    buffer = serialPort.readBytes();
                    System.out.println(bytesToHex(buffer) + " event");
                    for (int i = 0; i < buffer.length; i++) {
                        queue.add(new CustomByte(buffer[i], true));
                    }
                } catch (SerialPortException ex) {
                    System.out.println(ex);
                }
            }
            // }
        }
    }
    public static class SerialParser extends Thread {
        StringBuilder sb = new StringBuilder();
        Byte len[];
        int len_mess = 0;
        Byte mess[];
        @Override
        public void run() {
            while (true) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.size() + " 1 proverka");
                    sb = new StringBuilder();
                    byte stx = queue.poll().getBufferByte();
                    System.out.println(byteToHex(stx) + " parser");
                    if (stx == 0x02) {
                        sb.append(String.format("%02X ", stx));
                        System.out.println(queue.size() + " 2 proverka");
                        for (int i = 0; i < 3; i++) {
                            System.out.println(queue.size() + " 3 proverka " + i + " krug");
                            len[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(len[i]) + " parser");
                            //sb.append(String.format("%02X ", len[i]));
                        }
                        len_mess = (256 * 256 * len[0]) + (256 * len[1]) + (len[2]);
                        for (int i = 0; i < len_mess; i++) {
                            mess[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(mess[i]) + "parser");
                            sb.append(String.format("%02X ", mess[i]));
                            try {
                                Thread.sleep(50);
                            } catch (InterruptedException ex) {
                                System.out.println(ex.getMessage());
                            }
                        }
                        byte etx = queue.poll().getBufferByte();
                        System.out.println(byteToHex(etx) + "parser");
                        if (etx == 0x03) {
                            sb.append(String.format("%02X ", etx));
                            System.out.println(sb.toString());
                        } else {
                            System.out.println("NOT ETX");
                        }
                    } else {
                        System.out.println("NOT STX");
                    }
                    System.out.println(sb.toString());
                }
            }
        }
    }
}

相同的错误

02事件0000017703事件6 1证明2解析器75事件6 2证明6 3证明0克鲁格线程"thread-1"java.lang.NullPointerException中出现异常在e.moduli.ingenico_card_reader.ingenico_card_reader$SerialParser.run（ingenico_card_reader.java:129）

Answer 1

BlockingQueue<Byte>可以有(byte) 0x00值，但这是处理字节流的效率非常低的方法。这将为发送的每个实际字节创建大约16个字节的垃圾。

另一种方法是使用为这类任务设计的管道流。

PipedOutputStream out = new PipedOutputStream();
PipedInputStream in = new PipedInputStream(out);

在从RS232读取的线程中，您可以将读取的字节写入out，在另一个线程中，可以通过从in读取来处理此字节。

这种方法不会在每个字节的基础上创建任何垃圾。

Answer 2

您可以使用自定义Byte类包装Byte类：

public class CustomByte {
    private Byte bufferByte;
    private boolean isNull;
    // Add constructor, getters/setters as required
}

并更改队列类型以使用此类型。然后，当您遇到一个null字节时，只需添加一个带有标志的CustomByte对象：

queue.add(new CustomByte(buffer[i], true))

然后在轮询CustomByte对象时，可以查询isNull标志