java - ObjectOutputStream 只读取给它的第一个实例(java)？

Question

我已经多次看到这个问题，但老实说我不明白如何让它发挥作用。我有一个客户端和服务器应用程序，并且服务器有一个 ObjectOutputStream 变量，发送一个数组列表，其中包含一个双整数数组(这样做的原因是，因为它必须发送一个对象，并且因为普通数组不是对象，我将它包装在一个数组列表中，以便它能够发送)。客户端通过其 ObjectInputStream 变量接收它，但即使 double 组更改其数字，它也仅接收数组列表对象的第一个实例。我怎样才能让它更新它发送的对象？如何让 ObjectInputStream 每次都接收一个新对象？

-丹

服务器:

public class Send extends Thread{
     Starter start;
     PlayerArray array;
     Names name;
     public Send(Starter start, PlayerArray array, Names name){
         this.start = start;
         this.array = array;
         this.name = name;
     }
     public void run(){
         while(start.running){
             for(int i = 0; i < start.roomNum; i++){
                 if(start.send[i] != null && start.OOS[i] != null){
                      try{
                          array.setSendingArray(i);
                          start.OOS[i].writeObject(array.get());
                          start.OOS[i].flush();
                      }catch(Exception e){

                      }
                }
             }
         }
    }
}

服务器播放器数组类:(客户端相同):

public class PlayerArray{
Starter start;
int[][] players;
int[][] sending;
public PlayerArray(Starter start){
    this.start = start;
    players = new int[start.roomNum][2];
    defaultArray();
}
public int[][] getArray(){
    return players;
}
public ArrayList<int[][]> get(){
    ArrayList<int[][]> xyWrap = new ArrayList<int[][]>();
    xyWrap.add(sending);
    return xyWrap;
}
public void set(int[][] xy){
    players = xy;
}
public void set(int index, int newX, int newY){
    players[index][0] = newX;
    players[index][1] = newY;
}
public void setSendingArray(int i){
    //take out "i"'s x and y.
    sending = players;
    //sending[i][0] = -1;
    //sending[i][1] = -1;
}
public void defaultArray(){
    for(int i = 0; i < start.roomNum; i++){
        players[i][0] = -1;
        players[i][1] = -1;
    }
    sending = players;
}

客户:

public class Recieve extends Thread{
Starter start;
PlayerArray array;
Names name;
public Recieve(Starter start, PlayerArray array, Names name){
    this.start = start;
    this.array = array;
    this.name = name;
}
public void run(){
    while(start.running){
        try{
            ArrayList<int[][]> xy = new ArrayList<int[][]>();
            xy = (ArrayList<int[][]>)start.OIS.readObject();
            array.set(xy.get(0));
            int[][] testXY = array.getArray();
            System.out.println("X:  " + testXY[0][0] + "  Y:  " + testXY[0][1]);
        }catch(Exception e){
            System.err.println("CANNOT READ OBJECT!");
        }
    }
}
}

Answer 1

当您序列化一个对象时，它会用一个标记替换每个引用。这意味着，如果您两次引用同一个对象或两个对象相互引用，它仍然会正确(反)序列化对象。

这也意味着

• 两端都缓存了它们发送或接收的每个对象，这可能是内存泄漏的原因。
• 如果您更新对象并再次发送它，它不会“注意到”更改，并且您会获得对原始数据的引用。同样，如果您更改反序列化的对象，即使您更改了它，您仍然会获得相同的引用。

对于这两个问题都有一个解决方案，即在 ObjectOutputStream 上调用 reset()。这会清除缓存，防止对象消耗内存并强制它发送任何已发送的对象，然后重新发送。