Java 获得无限循环？

我使用android中的一个库连接到一个终端仿真器，它连接到一个串行设备（一个交换机）并向我显示发送/接收的数据。我使用另一个库通过串行方式发送数据。在这两种情况下，我通过终端下方的文本框或通过输入终端本身并在键盘上按enter键通过连接发送数据。我也可以通过按键发送命令

在我的活动中，我有一个名为

sendoserial

的方法，它只调用一个库方法，通过usb将数据发送到通过串行连接的设备

public static void sendOverSerial(byte[] data) {

        if(mSelectedAdapter !=null && data !=null){
        mSelectedAdapter.sendData(data);

      }}

此活动打开一个类的实例，该类用于将数据写入终端屏幕。通常，当我想通过串行方式发送数据时，通过

editText

和

按钮

调用活动中的

sendOverSerial

方法。但是，当我将字符写入终端本身时，它们会在这个新的实例

write

方法中被拾取。因此，我必须从该实例调用

sendoOverserial

方法。我的问题是，如果我调用它来编写下面的“TEST”，那么TEST将以无限循环的方式写入终端，它只是继续编写它。知道为什么吗？如果我像我评论的那样再往下发送，它只会像预期的那样发送一次

 public void write(byte[] bytes, int offset, int count) {

            int numCRs = 0;
            for (int i = offset; i < offset + count; ++i) {
                if (bytes[i] == '\r') {
                    ++numCRs;
                }
            }

            if (numCRs == 0) {
                // No CRs -- just send data as-is

                //infinite loop if I send from here
                GraphicsTerminalActivity.sendOverSerial("TEST".getBytes());

                super.write(bytes, offset, count);

                if (isRunning()) {
                   doLocalEcho(bytes);
                }
                return;
            }

            Log.d(TAG, "CRs=== " + numCRs);
            // Convert CRs into CRLFs
            byte[] translated = new byte[count + numCRs];
            int j = 0;
            for (int i = offset; i < offset + count; ++i) {
                if (bytes[i] == '\r') {
                    translated[j++] = '\r';
                    translated[j++] = '\n';
                } else {
                    translated[j++] = bytes[i];
                }
            }
           //fine if I send from here, sends once
            GraphicsTerminalActivity.sendOverSerial("SECOND TEST".getBytes());
           super.write(translated, 0, translated.length);

            // If server echo is off, echo the entered characters locally
            if (isRunning()) {
                doLocalEcho(translated);
            }                            
        }

然后在库中的另一个类bytequeue类中调用write

public void write(byte[] buffer, int offset, int length)
    throws InterruptedException {
        if (length + offset > buffer.length) {
            throw
                new IllegalArgumentException("length + offset > buffer.length");
        }
        if (length < 0) {
            throw
            new IllegalArgumentException("length < 0");

        }
        if (length == 0) {
            return;
        }
        synchronized(this) {
            int bufferLength = mBuffer.length;
            boolean wasEmpty = mStoredBytes == 0;
            while (length > 0) {
                while(bufferLength == mStoredBytes) {
                    wait();
                }
                int tail = mHead + mStoredBytes;
                int oneRun;
                if (tail >= bufferLength) {
                    tail = tail - bufferLength;
                    oneRun = mHead - tail;
                } else {
                    oneRun = bufferLength - tail;
                }
                int bytesToCopy = Math.min(oneRun, length);
                System.arraycopy(buffer, offset, mBuffer, tail, bytesToCopy);
                offset += bytesToCopy;
                mStoredBytes += bytesToCopy;
                length -= bytesToCopy;
            }
            if (wasEmpty) {
                notify();
            }
        }
    }

公共无效写入（字节[]缓冲区，整数偏移量，整数长度）
抛出中断异常{
if（长度+偏移量>缓冲区长度）{
扔
新的IllegalArgumentException（“长度+偏移量>缓冲区.length”）；
}
如果（长度<0）{
扔
新的IllegalArgumentException（“长度<0”）；
}
如果（长度==0）{
返回；
}
已同步（此）{
int bufferLength=mBuffer.length；
布尔值wasEmpty=mStoredBytes==0；
而（长度>0）{
while（bufferLength==mStoredBytes）{
等待（）；
}
int tail=mHead+mStoredBytes；
int oneRun；
如果（尾部>=缓冲长度）{
尾=尾-缓冲长度；
oneRun=mHead-tail；
}否则{
oneRun=缓冲长度-尾部；
}
int bytesToCopy=Math.min（oneRun，长度）；
System.arraycopy（缓冲区、偏移量、mBuffer、尾部、bytesToCopy）；
偏移量+=bytesToCopy；
mStoredBytes+=bytesToCopy；
长度-=bytesToCopy；
}
如果（为空）{
通知（）；
}
}
}

当数据被发送时，一个方法被自动调用，这个方法也有一个写入它的调用，等等viola，无限循环。

没有“无限循环”这样的东西。电池迟早会耗尽，某些资源会耗尽，或者某些组件会出现故障。或者你会厌倦等待。是的，它是某种循环的名称。即使不是这样，这也不是一个建设性的评论。你能发布或总结调用write的代码吗？您确定它会为单个要写入的调用显示无限次的“TEST”吗？我们可以看到super.write调用的写入代码吗？在write方法中设置一个断点，并将断点的“hit count”设置为10左右。然后，当您点击该断点时，请查看堆栈，它应该非常明显地显示循环发生的位置。

public void write(byte[] buffer, int offset, int length)
    throws InterruptedException {
        if (length + offset > buffer.length) {
            throw
                new IllegalArgumentException("length + offset > buffer.length");
        }
        if (length < 0) {
            throw
            new IllegalArgumentException("length < 0");

        }
        if (length == 0) {
            return;
        }
        synchronized(this) {
            int bufferLength = mBuffer.length;
            boolean wasEmpty = mStoredBytes == 0;
            while (length > 0) {
                while(bufferLength == mStoredBytes) {
                    wait();
                }
                int tail = mHead + mStoredBytes;
                int oneRun;
                if (tail >= bufferLength) {
                    tail = tail - bufferLength;
                    oneRun = mHead - tail;
                } else {
                    oneRun = bufferLength - tail;
                }
                int bytesToCopy = Math.min(oneRun, length);
                System.arraycopy(buffer, offset, mBuffer, tail, bytesToCopy);
                offset += bytesToCopy;
                mStoredBytes += bytesToCopy;
                length -= bytesToCopy;
            }
            if (wasEmpty) {
                notify();
            }
        }
    }