Question

我有以下代码结构。

Transaction类型的事务处理程序，它是Client Handler类中的一个字段，它与服务器进行通信。（客户端处理程序和服务器并置），客户端通过序列化对象消息与客户端处理程序进行通信。

当一个新的事务请求从客户端进来时，（使用对象输入流的readObject（）方法进入线程），然后我做了一系列trx_handler.setFoo（trx.getFoo）））。这工作正常，我可以处理第一个请求。但是当一个后续请求进来时（由于循环结构只在第一个请求完成后才开始执行，我发现trx处理程序已经重新初始化为其默认值，对象仍然存在，但是里面的所有值都是什么可以导致这个问题？

我的第一个猜测是垃圾收集，但在我的Client Handler类中，始终有一个指向这个trx_handler的指针。

下面的代码说明了会发生什么。语句首先是start类型，因此将正确初始化trx_handler。然后将调用handle_statement。然后应该接收后续语句，但此时trx_handler已重新初始化为其默认设置，因此access_set字段为空，会话ID也是如此，并且对hande_statement中对象的修改都不可见

由于

  public class Handler { 

  private Statement trx_handler; 

 /* Constructor initialises trx_handler to new Statement(); */

 public ClientHandler(final Socket socket, long uid, Server server, ObjectInputStream ois) throws           IOException, Exception {
 LOGGER.info("Constructing Handler");
 this.uid = uid;
 this.server = server;
 this.socket = socket;
 this.database = server.getDB();
 this.trx_sys = database.getTransactionManager();
 create_listening(socket, ois);
 out = socket.getOutputStream();
 oos = new ObjectOutputStream(out);
 this.trx_handler = new Statement(false);

}

  private void create_incoming(final Socket socket, final ObjectInputStream stream) {
  Thread incoming = new Thread() {
  @Override
  public void run() {
    ObjectInputStream ois = stream;
    InputStream in = null;
    while (true) {
      Object statement = null;

      try {

        statement = ois.readObject();
        execute_stat(statement, socket, null);
        LOGGER.info("Ready to execute next "); 
      } catch (SocketException e) {
        LOGGER.severe("Connection Closed");
        return;
      } catch (IOException e) {
        LOGGER.severe("Connection Closed");
        return;
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
      } catch (Exception e) {
        e.printStackTrace();
        String error_message = e.getMessage();
        send_error(socket, error_message);
      }

    }
  }
};
incoming.setDaemon(true);
incoming.start();

}

 private synchronized void execute_stat(Statement trx) {
  if (trx.getTransactionState() == Consts.trx_end) {
    trx_sys.commitTransaction(trx_handler);
    return;
  } else if (trx.getTransactionState() == Consts.trx_start) {
   try {
    trx_handler.setAccessSet(trx.getAccessSet());
    trx_handler.setSession_id(trx.getSession_id());
    trx_sys.startTransaction(trx_handler);
    handle_statement(socket, trx_handler);


    /* TEST HERE THAT FIELDS IN TRX_HANDLER ARE CORRECTLY SET (INCLUDING SOME MODIFIED IN       
    handle_statement and they are correctly set */

  return;
  } catch (Exception ex) {
    Logger.getLogger(ClientHandler.class.getName()).log(Level.SEVERE, null, ex);
  }
}
try {
  LOGGER.info("Execute Trx: stat");

  /* Can't see modifications made in the start case */ 
  Statement stats = trx.getStatement();
  trx_handler.setStatement(stats);
  handle_statement(stats, socket, trx_handler);

} catch (Exception e) {
  e.printStackTrace();

}

return;
}

Answer 1

您需要为每笔交易发送一个全新的对象，使用ObjectOutputStream.writeUnshared()，或者在发送之间调用ObjectOutputStream.reset()。

Java对象返回默认值

1 个答案: