大约一小时后运行较慢的Java异步客户端

我尝试连接异步套接字并每秒读取一次新消息

我使用了示例客户机代码（）并在

getTextFromUser

方法中添加了

sleep

方法（1000毫秒），并从用户中删除了read命令

另外，我在

ReadWriteHandler

方法中添加了额外的逻辑。它一开始工作得很好，但在大约一个小时后，程序被挂起并开始工作（执行我的附加逻辑），不是每秒一次，而是大约每10分钟一次

你知道会发生什么吗

代码的一部分：

public void ConnectAsynchr() {


 try {   


     this.channel = AsynchronousSocketChannel.open();
    SocketAddress serverAddr = new InetSocketAddress("localhost", PortNumberAsynchr);
    Future<Void> result = channel.connect(serverAddr);

    try {
        result.get();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ExecutionException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }



    this.writeLog("ConnAsynch", "Asynchronous connection succesful established", true);

    this.connectAsynch = true;
    this.attach = new Attachment();
    this.attach.channel = this.channel;
    this.attach.buffer = ByteBuffer.allocate(16384);
    this.attach.isRead = false;
    this.attach.mainThread = Thread.currentThread();


    ReadWriteHandler readWriteHandler = new ReadWriteHandler();
    this.channel.write(this.attach.buffer, this.attach, readWriteHandler);

    try {
        this.attach.mainThread.join();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        this.writeLog("ERROR", e.toString(), false);
        e.printStackTrace();
    }


 }
 catch (IOException e) {
     this.writeLog("ERROR", e.toString(), false);
     System.out.println(e);

 }

}



class Attachment {
  AsynchronousSocketChannel channel;
  ByteBuffer buffer;
  Thread mainThread;
  boolean isRead;
}
class ReadWriteHandler implements CompletionHandler<Integer, Attachment> {
  @Override
  public void completed(Integer result, Attachment attach) {
    if (attach.isRead) {
      attach.buffer.flip();
      Charset cs = Charset.forName("UTF-8");
      int limits = attach.buffer.limit();
      byte bytes[] = new byte[limits];
      attach.buffer.get(bytes, 0, limits);
      String msg = new String(bytes, cs);


      writeLog("Asynchr Msg rec", msg, false);



      AsynchrMessLogic(msg);



      try {
        msg = this.getTextFromUser();
      } catch (Exception e) {
        e.printStackTrace();
      }
      if (msg.equalsIgnoreCase("bye")) {
        attach.mainThread.interrupt();
        return;
      }

       attach.buffer.clear();
      byte[] data = msg.getBytes(cs);
      attach.buffer.put(data);
      attach.buffer.flip();
      attach.isRead = false; // It is a write
      attach.channel.write(attach.buffer, attach, this);
    }else {
      attach.isRead = true;
      attach.buffer.clear();
      attach.channel.read(attach.buffer, attach, this);
    }
  }
  @Override
  public void failed(Throwable e, Attachment attach) {
    e.printStackTrace();
  }
  private String getTextFromUser() throws Exception{
    /*System.out.print("\nPlease enter a  message  (Bye  to quit):");
    BufferedReader consoleReader = new BufferedReader(
        new InputStreamReader(System.in));
    String msg = consoleReader.readLine();
    */
    Thread.sleep(threadSleep);
    String msg="aaa";
    return msg;
  }
}

public void ConnectAsynchr（）{
试试{
this.channel=AsynchronousSocketChannel.open（）；
SocketAddress serverAddr=新的InetSocketAddress（“localhost”，PortNumberAsynchr）；
未来结果=channel.connect（serverAddr）；
试一试{
result.get（）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（执行例外）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
this.writeLog（“connaxynch”，“异步连接成功建立”，true）；
this.connectAsynch=true；
this.attach=新附件（）；
this.attach.channel=this.channel；
this.attach.buffer=ByteBuffer.allocate（16384）；
this.attach.isRead=false；
this.attach.mainThread=Thread.currentThread（）；
ReadWriteHandler ReadWriteHandler=新的ReadWriteHandler（）；
this.channel.write（this.attach.buffer、this.attach、readWriteHandler）；
试一试{
this.attach.mainThread.join（）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
this.writeLog（“ERROR”，例如toString（），false）；
e、 printStackTrace（）；
}
}
捕获（IOE异常）{
this.writeLog（“ERROR”，例如toString（），false）；
系统输出打印ln（e）；
}
}
班级附件{
异步通道；
ByteBuffer缓冲器；
主线程；
布尔isRead；
}
类ReadWriteHandler实现CompletionHandler{
@凌驾
公共作废已完成（整数结果，附件附加）{
如果（请附上isRead）{
attach.buffer.flip（）；
字符集cs=Charset.forName（“UTF-8”）；
int limits=attach.buffer.limit（）；
字节字节[]=新字节[限制]；
attach.buffer.get（字节，0，限制）；
String msg=新字符串（字节，cs）；
writeLog（“Asynchr Msg rec”，Msg，false）；
异步消息逻辑（msg）；
试一试{
msg=this.getTextFromUser（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
如果（消息equalsIgnoreCase（“bye”））{
attach.mainThread.interrupt（）；
返回；
}
attach.buffer.clear（）；
byte[]data=msg.getBytes（cs）；
attach.buffer.put（数据）；
attach.buffer.flip（）；
attach.isRead=false；//这是一个写操作
attach.channel.write（attach.buffer，attach，this）；
}否则{
attach.isRead=true；
attach.buffer.clear（）；
attach.channel.read（attach.buffer，attach，this）；
}
}
@凌驾
公共作废失败（可丢弃e，附加附件）{
e、 printStackTrace（）；
}
私有字符串getTextFromUser（）引发异常{
/*System.out.print（“\n请输入消息（再见，退出）：”；
BufferedReader控制台Reader=新BufferedReader(
新的InputStreamReader（System.in））；
字符串msg=consolerereader.readLine（）；
*/
线程睡眠（threadSleep）；
字符串msg=“aaa”；
返回味精；
}
}

每次建立连接时，都会连接到主线程。这样做意味着您最终将耗尽可用的IO描述符，这可能正是正在发生的情况。从你的例子开始，你真的知道为什么它建议你加入主线程吗？我对这个主题是新手，我使用示例代码。我不知道和主线程的连接是什么，但我在运行程序时只建立了一次连接。每次你们建立连接，你们就和主线程连接。这样做意味着您最终将耗尽可用的IO描述符，这可能正是正在发生的情况。从你的例子开始，你真的知道为什么它建议你加入主线程吗？我对这个主题是新手，我使用示例代码。我不知道用主线程连接什么，但我在运行程序时只建立了一次连接。