Java 网络发送的矢量仅在客户端更新一次？

好的，我试着从服务器向客户端发送一个对象向量。客户端从向量中控制一个对象，并将其x和y发送到服务器向量

据我所知，现在服务器运行良好。事情正在实时更新，但客户端似乎只在启动时更新一次

这是客户端代码：

import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;

import java.io.*;
import java.net.*;
import java.util.Vector;

public class SlickClient extends BasicGame{

    ClientThread ct;
    Vector<Player> players;
    Player me;
    int ALL_KEYS = 0xFF;
    boolean keys[];

    public SlickClient()
    {
        super("Test Online Client - by William Starkovich");
    }

    public void init(GameContainer gc) throws SlickException {
        try{
            keys = new boolean[ALL_KEYS];

            for(int i = 0; i < ALL_KEYS; i++){
                keys[i] = false;
            }

            players = new Vector<Player>();

            connect();
        }

        catch(Exception e){

        }
    }

    public void connect(){
        String ip = "127.0.0.1";
        ct = new ClientThread(ip);
        ct.start();
        ct.setPriority(Thread.MAX_PRIORITY);

        me = ct.me;
        players = ct.players;
    }

    public void update(GameContainer gc, int delta)throws SlickException{
        controls();

        players = new Vector<Player>();

        System.out.println("ct size: " + ct.players.size());

        me = ct.me;
        players = ct.players;
    }

    public void render(GameContainer gc, Graphics g) throws SlickException{
        g.setColor(Color.black);
        g.fillRect(0,0,640,480);

        for(int i = 0; i < players.size(); i++){
            g.setColor(Color.cyan);
            g.fillRect(players.get(i).x, players.get(i).y, 50, 50);
        }

        g.drawString("Players: " + players.size(), 50, 10);
    }

    public void keyPressed(int key, char c) {
        keys[key] = true;
    }

    public void keyReleased(int key, char c) {
        keys[key] = false;
    }

    public void controls(){
        if(keys[Input.KEY_UP]){
            me.y--;
        }

        else if(keys[Input.KEY_DOWN]){
            me.y++;
        }

        else if(keys[Input.KEY_LEFT]){
            me.x--;
        }

        else if(keys[Input.KEY_RIGHT]){
            me.x++;
        }
    }

    public static void main(String[] args) throws SlickException{
     AppGameContainer app =
        new AppGameContainer( new SlickClient() );

     app.setShowFPS(false);
     app.setAlwaysRender(true);
     app.setTargetFrameRate(60);
     app.setDisplayMode(800, 600, false);
     app.start();
    }
}

class ClientThread extends Thread implements Runnable{
    Socket socket;
    Vector<Player> players;
    int playerID;
    Player me;
    DataOutputStream out;
    ObjectInputStream in;
    boolean loop = true;

    @SuppressWarnings("unchecked")
    public ClientThread(String ip){
        super("ClientThread");

        try{
            this.players = new Vector<Player>();
            socket = new Socket(ip, 4444);
            socket.setTcpNoDelay(true);
            out = new DataOutputStream(socket.getOutputStream());
            in = new ObjectInputStream(socket.getInputStream());
            playerID = in.readInt(); 
            this.players = (Vector<Player>) in.readObject();

            if(this.players != null)
                System.out.println("Not Null: " + this.players.size());

            boolean b = false;
            for(int i = 0; i < this.players.size(); i++){
                if(!b){
                    if(this.players.get(i).id == playerID){
                        me = this.players.get(i);
                        b = true;
                    }
                }
            }
        }

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

    public void run(){
        try{
            while(loop){
                try{
                    if(!socket.isClosed() && socket.isConnected()){
                        out.writeInt(me.x);
                        out.writeInt(me.y);
                        out.flush();

                        this.players = new Vector<Player>();
                        this.players = (Vector<Player>) in.readObject();

                        System.out.println("size" + players.size());
                        sleep(15);
                    }

                    else
                        loop = false;

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



        }

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

import org.newdawn.slick.AppGameContainer；
导入org.newdawn.slick.BasicGame；
导入org.newdawn.slick.Color；
导入org.newdawn.slick.GameContainer；
导入org.newdawn.slick.Graphics；
导入org.newdawn.slick.Input；
导入org.newdawn.slick.SlickException；
导入java.io.*；
导入java.net。*；
导入java.util.Vector；
公共类SlickClient扩展了BasicGame{
客户端线程ct；
向量机；
玩我；
int ALL_KEYS=0xFF；
布尔键[]；
公共客户机（）
{
超级（“测试在线客户端-由William Starkovich编写”）；
}
公共void init（GameContainer gc）引发异常{
试一试{
keys=新布尔值[所有_键]；
对于（int i=0；i

编辑：以下是服务器代码：

import java.net.*;
import java.util.Vector;
import java.io.*;
import javax.swing.*;
import java.io.Serializable;

public class SlickServer extends JFrame{

    private static final long serialVersionUID = 1L;

    JTextArea textArea;
    JScrollPane scrollPane;

    public SlickServer(){
        super("Test Online Server - by William Starkovich");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(500, 100);
        setLocationRelativeTo(null);

        textArea = new JTextArea();

        scrollPane = new JScrollPane(textArea);

        //getContentPane().add(textArea);
        getContentPane().add(scrollPane);
    }

    public static void main(String[] args) throws IOException {

        Vector<Player> player = new Vector<Player>();

        SlickServer ss = new SlickServer();
        ss.setVisible(true);

        ServerSocket serverSocket = new ServerSocket(4444);
        boolean listening = true;

        int playerID = 0;

        while(listening){
            ss.textArea.append("Waiting to connect with player: " + playerID  + "\n");
            new ClientThread(serverSocket.accept(), player, playerID, ss.textArea).start();
            playerID++;
            ss.textArea.append("Players: " + player.size() + "\n");
        }

        serverSocket.close();
        System.exit(0);
    }
}


class ClientThread extends Thread implements Runnable{
    int playerID;
    Socket acceptedSocket;
    JTextArea textArea;
    Vector<Player> players;
    Player me;

    public ClientThread(Socket acceptedSocket, Vector<Player> players, int playerID, JTextArea textArea){
        super("ClientThread");
        this.acceptedSocket = acceptedSocket;
        this.players = players;
        players.add(new Player(50,50, playerID));

        if(players != null)
            System.out.println("Not Null: " + players.size());

        boolean b = false;
        for(int i = 0; i < players.size(); i++){
            if(!b){
                if(players.get(i).id == playerID){
                    me = players.get(i);
                    b = true;
                }
            }
        }

        this.playerID = playerID;
        this.textArea = textArea;
    }

    public void run(){
        try{
            Socket clientSocket = acceptedSocket;
            clientSocket.setTcpNoDelay(true);
            textArea.append("Accepted. Now creating I/O.\n");
            DataInputStream in = new DataInputStream(clientSocket.getInputStream());
            ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
            textArea.append("player connected. \n");
            out.writeInt(me.id);
            out.writeObject(players);
            out.flush();

            while(!clientSocket.isClosed() && clientSocket.isConnected()){

                me.x = in.readInt();
                me.y = in.readInt();

                if(players != null)
                    System.out.println("Not Null: " + players.size());


                textArea.append("PlayerID: " + playerID + " Players: " + players.size() + " me.x: " + me.x + " me.y: " + me.y + "\n");

                out.writeObject(players);
                out.flush();

               sleep(15);
            }

        }

        catch(Exception e){
            e.printStackTrace();
            System.exit(1);
        }


    }

}


class Player implements Serializable{
    private static final long serialVersionUID = 1L;
    int x;
    int y;
    int id;

    public Player(int x, int y, int id){
        this.x = x;
        this.y = y;
        this.id = id;
    }
}

import java.net.*；
导入java.util.Vector；
导入java.io.*；
导入javax.swing.*；
导入java.io.Serializable；
公共类服务器扩展了JFrame{
私有静态最终长serialVersionUID=1L；
JTextArea textArea；
JScrollPane滚动窗格；
公共服务器（）{
超级（“测试在线服务器-威廉·斯塔科维奇编写”）；
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
设置大小（500100）；
setLocationRelativeTo（空）；
textArea=新的JTextArea（）；
scrollPane=新的JScrollPane（textArea）；
//getContentPane（）.add（文本区域）；
getContentPane（）.add（滚动窗格）；
}
公共静态void main（字符串[]args）引发IOException{
向量播放器=新向量（）；
SlickServer ss=新的SlickServer（）；
ss.setVisible（true）；
ServerSocket ServerSocket=新的ServerSocket（4444）；
布尔监听=真；
int playerID=0；
边听{
ss.textArea.append（“正在等待与playe连接
out.reset();
out.writeObject(players);
out.flush();