用于读写java的线程

我从串行端口读取数据的平均间隔是1秒，同时将读取的数据写入textArea和textfile，问题是我在某个时间没有得到正确的数据，可能是因为我在一个程序中完成了所有这三个过程，如何通过单独的thred写入文本区域和文本文件

这是我的代码：

import java.io.BufferedWriter;
import java.io.File;

import java.io.FileWriter;

import java.io.IOException;
import java.io.InputStream;

import java.text.SimpleDateFormat;

import java.util.Date;
import java.util.Iterator;

import java.util.TooManyListenersException;
import java.util.TreeMap;

import javax.comm.CommPortIdentifier;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;
import javax.swing.JOptionPane;

import com.pressure.constants.Constants;

import com.pressure.online.OnlineStartWindow;

public class SerailReader implements SerialPortEventListener {

    // DECLARES INPUT STREAM TO READ SRIAL PORT
    private InputStream inputStream;
    // DECLARES PORT
    private CommPortIdentifier port;
    private SerialPort serialPort;

    // DATE TO CREATE FILE NAME
    private static final SimpleDateFormat SDF = new SimpleDateFormat("dd-MM-yy");


    private int index = 0;

    private File file;

    private OnlineStartWindow onlineStartwindow;

    private int[] tempIntArray = new int[233];
    private int newData = 0;

    private String outFolder;

    private String filename = "0";

    private FileWriter fileWriter;

    private BufferedWriter buffOut;
    private StringBuffer line;
    private String packetFilename;

    TreeMap<Integer, Float> channelMap = new TreeMap<Integer, Float>();

    ThreadPrintsAndWrites p;

    public FileWriter getFileWriter() {
        return fileWriter;
    }

    public void setFileWriter(FileWriter fileWriter) {
        this.fileWriter = fileWriter;
    }

    public BufferedWriter getBuffOut() {
        return buffOut;
    }

    public void setBuffOut(BufferedWriter buffOut) {
        this.buffOut = buffOut;
    }

    // SETTER GETTER TO OnlineStartwindow OBJECT
    public OnlineStartWindow getOnlineStartwindow() {
        return onlineStartwindow;
    }

    public void setOnlineStartwindow(OnlineStartWindow onlineStartwindow) {
        this.onlineStartwindow = onlineStartwindow;
    }

    // SETTER GETTER TO SERIALPORT
    public SerialPort getSerialPort() {
        return serialPort;
    }

    public void setSerialPort(SerialPort serialPort) {
        this.serialPort = serialPort;
    }

    // ********* connects to serial port ***********//
    public void SerialReadmethod(OnlineStartWindow onlineStartwindow,
            String outFolderPath) throws Exception {

        setOnlineStartwindow(onlineStartwindow);
        outFolder = outFolderPath;
        // SELECTS PORT NAME SELECTED

        port = CommPortIdentifier.getPortIdentifier(getOnlineStartwindow()
                .getComPort());
        System.out.println("port name " + port);

        // CHEAK WETHER SELECTED PORT AVAILABLE OR NOT
        if (port.getPortType() == CommPortIdentifier.PORT_SERIAL) {

            if (port.getName().equals(getOnlineStartwindow().getComPort())) {

                JOptionPane.showMessageDialog(null, "Successpully opened port",
                        "Online Dump", JOptionPane.INFORMATION_MESSAGE);

            }

        }

        // OPENS SERAIL PORT
        serialPort = (SerialPort) port.open("SimpleReadApp1111", 1000);

        // OPENS SERIAL PORT INPUT STREAM TO READ DATA
        try {
            inputStream = serialPort.getInputStream();

        } catch (IOException e) {
            System.out.println("IO Exception");
        }

        // ADDS LISTNER TO SERIALPORT
        try {
            serialPort.addEventListener(this);

        } catch (TooManyListenersException e) {
            System.out.println("Tooo many Listener exception");
        }

        // EVENT GENERATED WHEN DATA WILL BE AVAILABELE ON SERIALPORT
        // INPUTSTREAM
        serialPort.notifyOnDataAvailable(true);

        try {

            // SETS SELECTED BAUDRATE

            int BAUDRATE = Integer.parseInt((getOnlineStartwindow()
                    .getBaudRate()).trim());

            // SETS SELECTED DATA BITS

            int DATABITS = Integer.parseInt(getOnlineStartwindow()
                    .getDataBits().trim());
            if (DATABITS == 8) {
                DATABITS = SerialPort.DATABITS_8;
            } else if (DATABITS == 7) {
                DATABITS = SerialPort.DATABITS_7;
            } else if (DATABITS == 6) {
                DATABITS = SerialPort.DATABITS_6;
            } else if (DATABITS == 5) {
                DATABITS = SerialPort.DATABITS_5;
            }

            // SETS SELECTED STOPBITS
            int STOPBITS = 0;

            if (getOnlineStartwindow().getStopBits() == "1") {
                STOPBITS = SerialPort.STOPBITS_1;
            } else if (getOnlineStartwindow().getStopBits() == "1.5") {
                STOPBITS = SerialPort.STOPBITS_1_5;
            } else if (getOnlineStartwindow().getStopBits() == "2") {
                STOPBITS = SerialPort.STOPBITS_2;
            }

            // SETS SELECTED PARITY
            int PARITY = 0;
            if (getOnlineStartwindow().getParity() == "NONE") {
                PARITY = SerialPort.PARITY_NONE;
            } else if (getOnlineStartwindow().getParity() == "EVEN") {
                PARITY = SerialPort.PARITY_EVEN;
            } else if (getOnlineStartwindow().getParity() == "ODD") {
                PARITY = SerialPort.PARITY_ODD;
            }

            // SETS SELECTED FLOW CONTROL
            int FLOWCONTROL = 0;
            if (getOnlineStartwindow().getFlowControl() == "NONE") {
                FLOWCONTROL = SerialPort.FLOWCONTROL_NONE;
            } else if (getOnlineStartwindow().getFlowControl() == "XON/XOFF") {
                FLOWCONTROL = SerialPort.FLOWCONTROL_XONXOFF_IN;
            }

            serialPort
                    .setSerialPortParams(BAUDRATE, DATABITS, STOPBITS, PARITY);

            // no handshaking or other flow control
            serialPort.setFlowControlMode(FLOWCONTROL);


        } catch (UnsupportedCommOperationException e) {
            System.out.println("UnSupported comm operation");
        }

    }

    // *********this method will automaticaly calls when u get data on port and
    // arranges packet from start frame to end frame *************//
    public void serialEvent(SerialPortEvent event) {

//      switch (event.getEventType()) {
//
//      case SerialPortEvent.DATA_AVAILABLE:

        if(event.getEventType()==SerialPortEvent.DATA_AVAILABLE){

                //dataAvailabel = inputStream.available();

                // READING DATA CHARECTER BY CHARECTER

                while (newData != -1) {
                    try {
                        newData = inputStream.read();
                        if (newData == -1) {
                            break;
                        }
                        if (Constants.SF == (char) newData) {
                            index = 0;
                            // System.out.println("start frame");
                        }
                        tempIntArray[index] = newData;

                        if (Constants.EF == (char) newData) {
                            selectToDispalyAndWrite(tempIntArray);
                            // disp(tempIntArray);

                        }
                        index++;

                    } catch (IOException ex) {
                        System.err.println(ex);
                        // return;
                    }
                }
                // ///////////////// completes
        }




    }

    // DISPLYS PACKET TO TEXT AREA AND CREATES .PSI FILE
    public void selectToDispalyAndWrite(int[] readBufferArray) {

        if (getOnlineStartwindow().getDump().isSelected()) {
            packetFilename = Integer.toString(readBufferArray[1])
                    + Integer.toString(readBufferArray[2])
                    + Integer.toString(readBufferArray[3]);


            try {
                if (getOnlineStartwindow().getFileTypeSelection() == "text") {

                    displayAndWriteToTextFile(readBufferArray);

                } else {
                    displayAndWriteToExcelFile(readBufferArray);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            printToTextArea(readBufferArray);
        }
    }

    public void printToTextArea(int[] readBufferArray) {
        int i = 0;
        int portname = 0;
        Float portval = 0.0f;


        int len = 0;
        i = 0;
    writeloop:   while (len != readBufferArray.length) {
            // while ((char) readBufferArray[i] != Constants.EF) {
            if ((char) readBufferArray[i] == Constants.SF) {

                // WRITES DASH LINE TO TEXT AREA
                getOnlineStartwindow()
                        .getTextArea()
                        .append(
                                "\r\n\r\n-----------------------------------------------------------------------\r\n");

                getOnlineStartwindow().getTextArea().append(
                        "Time :" + readBufferArray[i + 4] + " Min "
                                + readBufferArray[i + 5] + " Sec.");
                getOnlineStartwindow()
                        .getTextArea()
                        .append(
                                "\r\n-----------------------------------------------------------------------\r\n");



            }
            if ((char) readBufferArray[i] == Constants.EF) {
                for (Iterator<Integer> iterator = channelMap.keySet()
                        .iterator(); iterator.hasNext();) {

                    int key = iterator.next();
                    Float value = channelMap.get(key);

                    getOnlineStartwindow().getTextArea().append(
                            "Port_" + key + "           " + value + "\r\n");

                }
                channelMap.clear();
                break writeloop;
            }
            i++;
        }

    }

    public void displayAndWriteToTextFile(int[] readBufferArray)
            throws IOException {
        int i = 0;
        int portname = 0;
        Float portval = 0.0f;

        if (!(filename.equalsIgnoreCase(packetFilename))) {
            filename = packetFilename;
            if (buffOut != null && fileWriter != null) {
                drawLine('*');
                buffOut.close();
                fileWriter.close();

            }

            // GET CURRENT DATE
            Date date = new Date();
            file = new File(outFolder + "\\" + SDF.format(date) + "-"
                    + packetFilename + ".txt");

            if (!file.exists()) {
                fileWriter = new FileWriter(file, true);
                buffOut = new BufferedWriter(fileWriter);

                drawLine('*');

                drawLine('*');
            } else {
                fileWriter = new FileWriter(file, true);
                buffOut = new BufferedWriter(fileWriter);
            }

        }

        // LOOP TO DISPLY ALL PORT NAME AND PRESSURE VALUES
        int len = 0;
        i = 0;
        writeloop: while (len != readBufferArray.length) {
            // while ((char) readBufferArray[i] != Constants.EF) {
            if ((char) readBufferArray[i] == Constants.SF) {

                // WRITES DASH LINE TO TEXT AREA
                getOnlineStartwindow()
                        .getTextArea()
                        .append(
                                "\r\n\r\n-----------------------------------------------------------------------\r\n");

                getOnlineStartwindow().getTextArea().append(
                        "Time :" + readBufferArray[i + 4] + " Min "
                                + readBufferArray[i + 5] + " Sec.");
                getOnlineStartwindow()
                        .getTextArea()
                        .append(
                                "\r\n-----------------------------------------------------------------------\r\n");

                drawLine('-');
                buffOut.write("TIME: " + readBufferArray[i + 4] + " Min "
                        + readBufferArray[i + 5] + " Sec." + "\r\n\r\n");

            }
            if ((char) readBufferArray[i] == Constants.ST) {

                portname = readBufferArray[i + 1];
                portval = getFloatValue(i);
                channelMap.put(portname, portval);

            }
            if ((char) readBufferArray[i] == Constants.EF) {
                for (Iterator<Integer> iterator = channelMap.keySet()
                        .iterator(); iterator.hasNext();) {

                    int key = iterator.next();
                    Float value = channelMap.get(key);

                    getOnlineStartwindow().getTextArea().append(
                            "Port_" + key + "           " + value + "\r\n");



                }
                channelMap.clear();
                break writeloop;
            }
            i++;
        }

    }
}

导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.io.InputStream；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入java.util.Iterator；
导入java.util.ToomanyListenerException；
导入java.util.TreeMap；
导入javax.comm.CommPortIdentifier；
导入javax.comm.SerialPort；
导入javax.comm.SerialPortEvent；
导入javax.comm.SerialPortEventListener；
导入javax.comm.unsupportedComOperationException；
导入javax.swing.JOptionPane；
导入com.pressure.constants.constants；
导入com.pressure.online.online startwindow；
公共类SerailReader实现SerialPortEventListener{
//声明输入流以读取SRIAL端口
私有输入流输入流；
//声明港口
专用通信识别端口；
专用串行端口串行端口；
//创建文件名的日期
专用静态最终SimpleDataFormat SDF=新SimpleDataFormat（“dd-MM-yy”）；
私有整数指数=0；
私有文件；
私人在线StarTwinDow Online StarTwinDow；
私有整数[]临时整数=新整数[233]；
私有int newData=0；
私人字符串输出器；
私有字符串filename=“0”；
私有文件编写器文件编写器；
专用缓冲写入程序buffOut；
专用缓冲线；
私有字符串packetFilename；
TreeMap channelMap=newtreemap（）；
线纹印刷机；
公共文件编写器getFileWriter（）{
返回文件编写器；
}
public void setFileWriter（FileWriter FileWriter）{
this.fileWriter=fileWriter；
}
公共缓冲写入程序getBuffOut（）{
返回输出；
}
公共无效setBuffOut（缓冲写入程序buffOut）{
this.buffOut=buffOut；
}
//SETTER GETTER到OnlineStartwindow对象
公共在线StarTwinDow getOnlineStartwindow（）{
在线返回startwindow；
}
公共无效设置OnlineStartWindow（OnlineStartWindow OnlineStartWindow）{
this.onlineStartwindow=onlineStartwindow；
}
//SETTER GETTER到SERIALPORT
公共SerialPort getSerialPort（）{
返回串口；
}
公共无效设置SerialPort（SerialPort SerialPort）{
this.serialPort=serialPort；
}
//*******连接到串行端口***********//
public void SerialReadmethod（OnlineStartWindow OnlineStartWindow，
字符串outFolderPath）引发异常{
设置onlineStartwindow（onlineStartwindow）；
outFolder=outFolderPath；
//选择所选的端口名
port=CommPortIdentifier.getPortIdentifier（getOnlineStartwindow（）
.getComPort（））；
System.out.println（“端口名称”+端口）；
//检查所选端口是否可用
if（port.getPortType（）==CommPortIdentifier.port_SERIAL）{
if（port.getName（）.equals（getOnlineStartwindow（）.getComPort（）））{
JOptionPane.showMessageDialog（空，“成功打开端口”，
“在线转储”，JOptionPane.信息（信息）；
}
}
//打开SERAIL端口
serialPort=（serialPort）port.open（“SimpleReadApp1111”，1000）；
//打开串行端口输入流以读取数据
试一试{
inputStream=serialPort.getInputStream（）；
}捕获（IOE异常）{
System.out.println（“IO异常”）；
}
//将LISTNER添加到SERIALPORT
试一试{
serialPort.addEventListener（此）；
}捕获（ToomanyListenerSE异常）{
System.out.println（“太多侦听器异常”）；
}
//数据将在SERIALPORT上可用时生成的事件
//输入流
serialPort.notifyOnDataAvailable（true）；
试一试{
//设置所选波特率
int BAUDRATE=Integer.parseInt（（getOnlineStartwindow（）
.getBaudRate（））.trim（）；
//设置选定的数据位
int-DATABITS=Integer.parseInt（getOnlineStartwindow（）
.getDataBits（）.trim（））；
如果（数据位==8）{
DATABITS=SerialPort.DATABITS_8；
}else if（数据位==7）{
DATABITS=SerialPort.DATABITS_7；
}else if（数据位==6）{
DATABITS=SerialPort.DATABITS_6；
}else if（数据位==5）{
DATABITS=SerialPort.DATABITS_5；
}
//设置选定的停止位
int停止位=0；
如果（getOnlineStartwindow（）.getStopBits（）=“1”）{
STOPBITS=SerialPort.STOPBITS_1；
}else if（getOnlineStartwindow（）.getStopBits（）=“1.5”）{
STOPBITS=SerialPort.STOPBITS_1_5；
}else if（getOnlineStartwindow（）.getStopBits（）=“2”）{
STOPBITS=SerialPort.STOPBITS_2；
}
//设置选定的奇偶校验
整数奇偶校验=0；
如果（getOnlineStartwindow（）.getParity（）=“无”）{
奇偶性=串行端口。奇偶性\u无；
}else if（getOnlineStartwindow（）.getParity（）=“偶数”）{
奇偶校验=串行端口。奇偶校验\u偶数；
}else if（getOnlineStartwindow（）.getParity（）=“奇数”）{
奇偶校验=串行端口。奇偶校验\奇数；
}
//设置选定的流控制
int-FLOWCONTROL=0；
如果（getOnlineStartwindow（）.getFlowControl（）=“无”）{
FLOWCONTROL=SerialPort.FLOWCONTROL\u无；
}else if（GetOnlineStartWidow（）.getFlowControl（）=“XON/XOFF”）{
FLOWCONTROL=串行端口。