Compiler-Fehler Heap space!

[stulleman]

Guten Abend zusammen!

Ich habe ein Problem mit meinem Projekt. Anfangs habe ich einen UDP Client und Server geschrieben die permanent Daten austauschen um zum Beispiel ein multiplayer Spiel zu realisieren. Das hat ganz gut geklappt, jedoch fand ich es etwas umständlich, also wollte ich es mit TCP versuchen, um auch Geschwindigkeit und Paketverluste zu vergleichen.

Ich habe wirklich alles versucht: Etliche syso's, VisualVM um zu gucken ob irgendein Programm mit den ganzen Heap Space raubt und den Debugger. Ich habe leider nichts gefunden. Ich poste jetzt mal die wichtigsten Codestellen, vielleicht fällt irgendjemanden ja mal was auf:

Client (Animation Thread) :

@Override
	public void run() {
		while(true) {
			long start = System.currentTimeMillis();

			update();
			connection.sendObject(MPConnection.TYPE_PLAYER_UPDATE, player);
			player_list = connection.getPlayerUpdate();
			repaint();

			long diff = System.currentTimeMillis() - start;

			if(diff >= 10) {
				diff = 5;
			}

			try {
				Thread.sleep(10 - diff);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

Client (Connection):

public class MPConnection implements Runnable {
	
	public static final int ERROR = -1;
	public static final int TYPE_MESSAGE = 0;
	public static final int TYPE_PLAYER_UPDATE = 1;
	public static final int TYPE_PLAYER_LIST = 2;
	
	private Socket socket;
	private DataInputStream in;
	private DataOutputStream out;
	private Thread thread;
	
	// Game specific variables
	
	private ArrayList<MPPlayer> player_list = new ArrayList<MPPlayer>();
	
	public void connectToServer(String ip, int port) {
		try {
			socket = new Socket(ip, port);
			
			in = new DataInputStream(socket.getInputStream());
			out = new DataOutputStream(socket.getOutputStream());
			
			thread = new Thread(this);
			thread.start();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void sendObject(int objectType, Object obj) {
		byte[] objectBytes = ObjectConverter.convertObjectToByteArray(obj);
		
		try {
			out.writeInt(objectType);
			out.writeInt(objectBytes.length);
			out.write(objectBytes);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public void run() {
		while(true) {
			int messageType = -1;
			
			try {
				messageType = in.readInt();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			if(messageType == TYPE_MESSAGE) {
				
			}
			
			if(messageType == TYPE_PLAYER_LIST) {
				try {
					int length = in.readInt();
					byte[] objectBytes = new byte[length];
					
					in.readFully(objectBytes);
					
					player_list = (ArrayList<MPPlayer>) ObjectConverter.convertByteArrayToObject(objectBytes);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	public ArrayList<MPPlayer> getPlayerUpdate() {
		return player_list;
	}
}

Server:

package de.pk.maximilian.games;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class MPServer implements Runnable {

	private Thread thread;
	private ServerSocket socket;
	private ArrayList<MPServerThread> clients = new ArrayList<MPServerThread>();
	
	// Game specific variables
	
	private ArrayList<MPPlayer> player_list = new ArrayList<MPPlayer>();
	
	public MPServer(int port) {
		System.out.print("Starting server on port " + port + "... ");
		
		try {
			socket = new ServerSocket(port);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("Running!");
		
		thread = new Thread(this);
		thread.start();
	}
	
	public void updatePlayerList(MPPlayer newPlayer) {
		for(MPPlayer oldPlayer: player_list) {
			if(oldPlayer.getId().equals(newPlayer.getId())) {
				player_list.set(player_list.indexOf(oldPlayer), newPlayer);
				broadcastObject(MPConnection.TYPE_PLAYER_LIST, player_list);
				return;
			}
		}
		player_list.add(newPlayer);
		broadcastObject(MPConnection.TYPE_PLAYER_LIST, player_list);
	}
	
	public void broadcastObject(int objectType, Object obj) {
		for(MPServerThread client: clients) {
			client.sendObject(objectType, obj);
		}
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Socket clientSocket = socket.accept();
				MPServerThread serverThread = new MPServerThread(clientSocket, this);
				clients.add(serverThread);
				
				System.out.println("Accepted new client (" + clientSocket.getLocalAddress().getHostAddress() + ")");
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			try {
				Thread.sleep(10);
			} catch(InterruptedException e) {
				e.printStackTrace(); 
			}
		}
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new MPServer(6493);
	}
}

ServerThread:

package de.pk.maximilian.games;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class MPServerThread implements Runnable {

	private Thread thread;
	private MPServer mpServer;
	private DataInputStream in;
	private DataOutputStream out;
	
	public MPServerThread(Socket socket, MPServer mpServer) {
		this.mpServer = mpServer;
		
		try {
			in = new DataInputStream(socket.getInputStream());
			out = new DataOutputStream(socket.getOutputStream());
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		thread = new Thread(this);
		thread.start();
	}
	
	public void sendObject(int objectType, Object obj) {
		byte[] objectBytes = ObjectConverter.convertObjectToByteArray(obj);
		
		try {
			out.writeInt(objectType);
			out.writeInt(objectBytes.length);
			out.write(objectBytes);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		while(true) {
			int messageType = -1;
			
			try {
				messageType = in.readInt();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			if(messageType == MPConnection.TYPE_PLAYER_UPDATE) {
				try {
					int length = in.readInt();
					byte[] objectBytes = new byte[length];
					
					in.readFully(objectBytes);
					
					MPPlayer player = (MPPlayer) ObjectConverter.convertByteArrayToObject(objectBytes);
					mpServer.updatePlayerList(player);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

[Xeonkryptos]

Da fehlt eindeutig die Beschreibung deines Problems. Du hast nur dein Vorgehen benannt, aber nicht, was du damit erzielen wolltest!

 

[bERt0r]

Naja alleine sowas wie "byte[] objectBytes = new byte[length];" in einer Endlosschleife ist schonmal nicht Heapsize freundlich. Warum musst du denn jedesmal ein neues Array anlegen? reicht nicht eines, wenn du ohnehin direkt danach das array in ein anderes Objekt umwandelst?