序列化java冻结我的程序
我有一个多人游戏。 我有一个java套接字服务器程序已经在运行 我正在向socketserver发送字符串，这些字符串接收良好 这是我的收发课：序列化java冻结我的程序,java,java-io,Java,Java Io,我有一个多人游戏。 我有一个java套接字服务器程序已经在运行 我正在向socketserver发送字符串，这些字符串接收良好 这是我的收发课： public class BaseServer { private String result = null; //for serializable class input stream ObjectInput input; // Declare client socket Socket clientSocke
public class BaseServer
{
private String result = null;
//for serializable class input stream
ObjectInput input;
// Declare client socket
Socket clientSocket = null;
// Declare output stream and string to send to server
DataOutputStream os = null;
// Declare input stream from server and string to store input received from server
BufferedReader is = null;
String responseLine;
//get ip
String serverAddress ;
// Create a socket on port 5000 and open input and output streams on that socket
public void setUpNetwork(String serverAd)
{
try
{
serverAddress = serverAd;
clientSocket = new Socket(serverAddress, 5000);
//string
os = new DataOutputStream(clientSocket.getOutputStream());
is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
//serial
input = new ObjectInputStream( clientSocket.getInputStream() );
}
catch (UnknownHostException e)
{
System.err.println("Don't know about host: hostname");
}
catch (IOException e)
{
System.err.println("Couldn't get I/O for the connection to: hostname");
}
}
/*
* Used to communicate with server
* takes message to send and the object expecting the response
* 1 simple method to replace all but one of the below v1 methods
*/
public BaseSerialDataObjects serverTalk(String message, BaseSerialDataObjects serializableobject){
sendStringMessage(message);
try {
switch(serializableobject.getClass().getSimpleName()){
case "PlayerPositionsSerial":
PlayerPositionsSerial serializableobject2 = (PlayerPositionsSerial) input.readObject();
return serializableobject2;
case "GameSettings":
return serializableobject = (GameSettings) input.readObject();
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
//Sends messages to the server
public void sendStringMessage(String message){
// Write data to the socket
if (clientSocket != null && os != null && is != null){
try {
os.writeBytes( message + "\n" );
}
catch (UnknownHostException e){
System.err.println("Trying to connect to unknown host: " + e);
}
catch (IOException e) {
System.err.println("IOException: " + e);
}
}
}
ObjectInput input;
input = new ObjectInputStream( socket.getInputStream() );
serializableobject = ( cast ) input.readObject();
input.flush();
import java.io.Serializable;
public class BaseSerialDataObjects implements Serializable{
}
/*
* class for game settings
* decided to split it and make it serializable incase of multi player
* thought this would be easier to standardise setting across multiple devices
*/
public class GameSettings extends BaseSerialDataObjects{
//GameWide variables
public String gameState;
public int winningNumberOfLaps = 1;
public String winString;
public long gameStartTime;
}
/*
* this class will be used on the server and each player will on request
* Receive a copy with player information
*/
public class PlayerPositionsSerial extends BaseSerialDataObjects {
//position 0 = name;
//position 1 = angle;
//position 2 = position x
//position 3 = position y
//position 4 = state
//position 5 = state in relation to server
public String[][] playersArray;
}
public class TCPserver implements Runnable
{
static Socket server = null;
static String gameState = "menu";
static int numberOfConnectedPlayers = 0;
private static final int possibleNumberOfPlayers = 8;
private static final int amountOfPlayerInfoHeld = 6;
private int threadNumber;
private static GameSettings gameSettings = new GameSettings();
//position 0 = name;
//position 1 = angle;
//position 2 = position x
//position 3 = position y
//position 4 = state
//position 5 = state in relation to server
//POssible states:
// connected
static PlayerPositionsSerial positions = new PlayerPositionsSerial();
public static void main( String args[] )
{
positions.playersArray = new String [possibleNumberOfPlayers][amountOfPlayerInfoHeld];
// Declare a server socket and a client socket for the server
ServerSocket service = null;
// Try to open a server socket on port 5000
try
{
service = new ServerSocket(5000);
server = service.accept();
Thread t0 = new Thread (new TCPserver(0));
t0.start();
server = service.accept();
Thread t1 = new Thread (new TCPserver(1));
t1.start();
server = service.accept();
Thread t2 = new Thread (new TCPserver(2));
t2.start();
server = service.accept();
Thread t3 = new Thread (new TCPserver(3));
t3.start();
server = service.accept();
Thread t4 = new Thread (new TCPserver(4));
t4.start();
server = service.accept();
Thread t5 = new Thread (new TCPserver(5));
t5.start();
server = service.accept();
Thread t6 = new Thread (new TCPserver(6));
t6.start();
server = service.accept();
Thread t7 = new Thread (new TCPserver(7));
t7.start();
/*server = service.accept();
Thread t8 = new Thread (new TCPserver(8));
t8.start(); */
}
catch (IOException e)
{
System.out.println(e);
}
}
public void run()
{
// Declare an input stream and String to store message from client
BufferedReader is;
String line;
// Declare an output stream to client
DataOutputStream os;
String thr = Integer.toString(threadNumber);
// Create a socket object from the ServerSocket to listen and accept
// connections. Open input and output streams
try
{
ObjectOutput output;
output = new ObjectOutputStream( server.getOutputStream() );
is = new BufferedReader( new InputStreamReader(
server.getInputStream()));
//if( (line = is.readLine()) != null )
while( (line = is.readLine()) != null )
{
if(line != null)
{
line = rules(line);
switch(line){
case "playertable":
output.writeObject( positions );
break;
case "gamesettings":
output.writeObject( gameSettings );
break;
}
}output.flush();
}
// Comment out/remove the stream and socket closes if server is to remain live.
is.close();
}
catch (IOException e)
{
System.out.println(e);
}
}
public TCPserver(int tNumber)
{
threadNumber = tNumber;
}
private synchronized void changeArray(int row, int col, String value)
{
positions.playersArray[row][col] = value;
}
private synchronized String readArray(int row, int col)
{
return positions.playersArray[row][col];
}
private String rules(String lineIn)
{
String returnString = "";
try {
String[] splitArray = lineIn.split("\\s+");
switch(splitArray[0])
{
case "signIn":
positions.playersArray[threadNumber][0] = splitArray[1];
positions.playersArray[threadNumber][amountOfPlayerInfoHeld-1] = "connected";
addPlayer();
returnString = "gamesettings ";
break;
case "ok":
// just for reply, do nothing response heard "ok"
break;
case "matchMake":
positions.playersArray[threadNumber][amountOfPlayerInfoHeld -1] = "matchmake";
gameSettings.gameState = "matchmake";
returnString = "playertable";
break;
case "ready":
positions.playersArray[threadNumber][amountOfPlayerInfoHeld -1] = "ready";
returnString = "gamesettings";
break;
case "requestStart":
boolean goAhead = true;
for(int i = 0 ; i < numberOfConnectedPlayers; i++)
{
if(positions.playersArray[i][amountOfPlayerInfoHeld-1] != "ready")
{
goAhead = false;
}
}
if(goAhead)
{
long start = System.currentTimeMillis( );
start = start + 10000;
gameSettings.gameStartTime = start;
}
returnString = "gamesettings";
break;
case "getPos":
returnString = splitArray[0] + " ";
returnString = "playertable";
break;
case "updatePos":
//heres where to notice crashes and check for wins etc...
positions.playersArray[threadNumber][1] = splitArray[1];
positions.playersArray[threadNumber][2] = splitArray[2];
positions.playersArray[threadNumber][3] = splitArray[3];
positions.playersArray[threadNumber][4] = splitArray[4];
returnString = "playertable";
break;
}
} catch (PatternSyntaxException ex) {
System.err.println("error: " + ex);
}
return returnString;
}
public synchronized void addPlayer()
{
numberOfConnectedPlayers++;
}
public synchronized int getNumberOfPlayers()
{
return numberOfConnectedPlayers;
}
public synchronized void removePlayer()
{
numberOfConnectedPlayers--;
}
}
公共类TCPserver实现可运行
{
静态套接字服务器=null；
静态字符串gameState=“menu”；
静态int numberOfConnectedPlayers=0；
私有静态final int-possibleNumberOfPlayers=8；
私有静态最终int-amountofplayerinfohold=6；
私有整数；
私有静态GameSettings GameSettings=新GameSettings（）；
//位置0=名称；
//位置1=角度；
//位置2=位置x
//位置3=位置y
//位置4=状态
//位置5=相对于服务器的状态
//可能的国家：
//连接的
静态播放位置序列位置=新播放位置序列（）；
公共静态void main（字符串参数[]）
{
positions.playersArray=新字符串[possibleNumberOfPlayers][amountofPlayerInFoHold]；
//声明服务器的服务器套接字和客户端套接字
ServerSocket服务=null；
//尝试打开端口5000上的服务器套接字
尝试
{
服务=新服务器插座（5000）；
server=service.accept（）；
线程t0=新线程（新TCPserver（0））；
t0.start（）；
server=service.accept（）；
线程t1=新线程（新TCPserver（1））；
t1.start（）；
server=service.accept（）；
线程t2=新线程（新TCPserver（2））；
t2.start（）；
server=service.accept（）；
线程t3=新线程（新TCPserver（3））；
t3.start（）；
server=service.accept（）；
线程t4=新线程（新TCPserver（4））；
t4.开始（）；
server=service.accept（）；
线程t5=新线程（新TCPserver（5））；
t5.开始（）；
server=service.accept（）；
线程t6=新线程（新TCPserver（6））；
t6.开始（）；
server=service.accept（）；
线程t7=新线程（新TCPserver（7））；
t7.start（）；
/*server=service.accept（）；
线程t8=新线程（新TCPserver（8））；
t8.start（）；*/
}
捕获（IOE异常）
{
系统输出打印ln（e）；
}
}
公开募捐
{
//声明输入流和字符串以存储来自客户端的消息
缓冲读取器是；
弦线；
//向客户端声明输出流
数据输出流；
字符串thr=Integer.toString（threadNumber）；
//从ServerSocket创建套接字对象以侦听和接受
//连接。打开输入和输出流
尝试
{
对象输出；
output=newObjectOutputStream（server.getOutputStream（））；
is=新的BufferedReader（新的InputStreamReader(
getInputStream（））；
//如果（（line=is.readLine（））！=null）
而（（line=is.readLine（））！=null）
{
如果（行！=null）
{
行=规则（行）；
道岔（线路）{
案例“playertable”：
output.writeObject（位置）；
打破
案例“游戏设置”：
output.writeObject（游戏设置）；
打破
}
}output.flush（）；
}
//如果服务器要保持活动状态，则注释掉/删除流并关闭套接字。
is.close（）；
}
捕获（IOE异常）
{
系统输出打印ln（e）；
}
}
公共TCPserver（整数）
{
螺纹编号=t编号；
}
私有同步void changeArray（int行、int列、字符串值）
{
positions.playerArray[行][列]=值；
}
专用同步字符串读取数组（int行，int列）
{
返回位置。playerArray[行][col]；
}
专用字符串规则（字符串行输入）
{
字符串returnString=“”；
试一试{
String[]splitArray=lineIn.split（\\s+）；
交换机（拆分阵列[0]）
{
案例“签名”：
positions.playersArray[threadNumber][0]=splitArray[1]；
positions.playersArray[threadNumber][amountofplayerinfohold-1]=“已连接”；
addPlayer（）；
returnString=“游戏设置”；
打破
案例“ok”：
//只是为了回答，什么也不做听到“ok”的回答
打破
案例“配对”：
PlayerArray[threadNumber][AmountOfflayerInFoHold-1]=“matchmake”；
gameSettings.gameState=“配对”；
returnString=“playertable”；
打破
案例“就绪”：
PlayerArray[threadNumber][AmountofPlayerInFoHold-1]=“就绪”；
returnString=“游戏设置”；
打破
案例“requestStart”：
布尔goAhead=true；
for（int i=0；iswitch(line){
case "playertable":
output.writeObject( positions );
break;
case "gamesettings":
output.writeObject( gameSettings );
break;
default:
// You should throw an exception or output an error message here
}
returnString = "gamesettings ";