Socket连接问题

Question

ServerSocket和Socket之间的连接，如果已经有一个Socket连接上了Server，然后又有第二个Scoket连接Server(server不开死循环等待连接)，这时候第二个Socket并没有发生异常，却不知道有没有连接上，我想让如果server已经有人连接上了，其他socket再连接就不能连了，要怎么做？不想用server返回一个消息给client作为判断依据

Answer 1

怎么个阻塞法？Socket s = new Socket("xxxx");
当ServerSocket已经实例化的时候，上面的Socket就不会有问题，而server这里我必须保持和第一个人的连接。

Answer 2

package com.xuz.csdn.june19;import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;public class Server { public static void main(String[] args) {
try {
ServerSocket server = new ServerSocket(1234);
Socket socket = null;
socket = server.accept(); OutputStream os = socket.getOutputStream();
String message = "hello," + socket.getPort();
for (int i = 0; i < 10; i++) {
os.write(message.getBytes());
os.flush();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
os.close();
} catch (IOException e) {
e.printStackTrace();
} 
}}
package com.xuz.csdn.june19;import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;public class Client { public static void main(String[] args) {
try {
Socket client = new Socket("127.0.0.1", 1234);
client.setSoTimeout(1000); InputStream is = client.getInputStream();
byte[] b = new byte[1024];
int size;
while ((size = is.read(b)) != -1) {
is.read(b);
System.out.println(new String(b, 0, size));
} is.close();
client.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (SocketException e) {
System.out.println("server is busy");
} catch (IOException e) {
e.printStackTrace();
}
}}
开2个client，第2个1秒后就提示server is busy了。

Answer 3

只要你的server端不把accept到得socket发给一个线程进行处理，基本就是阻塞式的了。

Answer 4

你这个是不是利用server一直在和clinet通信，所以才会产生阻塞啊？可是我那个server和client并不是一直在通信的，而是一个线程一直在等待对方的信息，而发送则是，随时都可以发的

Answer 5

public class GameConnector { /**连接器的端口*/
public static final int PORT = 8189;

/**表示玩家的身份，true为服务端，false为客户端*/
private boolean identity;

/**将收到的信息发送给该对象进行处理*/
private RecieveData recieve;

/**如果玩家是客户端则使用该端口进行连接*/
private Socket player;

/**如果玩家是服务端则开启该端口等待其他玩家连接*/
private ServerSocket server;

/**接收数据的线程*/
private Thread recieveThread;

private ObjectOutputStream out;


/**
 * 等到玩家连接进行游戏
 */
public void acceptPlayer() {
if(!identity) return;//如果该连接器的身份不是服务端则退出
new Thread(new Runnable() {
@Override
public void run() {
try {
server = new ServerSocket(PORT);
player = server.accept();
recieveData(player.getInputStream());//开启接收数据线程
out = new ObjectOutputStream(player.getOutputStream());
} catch(IOException e) {
e.printStackTrace();
JOptionPane.showMessageDialog(null, e.getMessage());
}
}
}).start();
}

/**
 * 连接服务端进行游戏
 * @param address 服务端地址
 * @throws IOException
 */
public void connectPlayer(String address) throws IOException {
if(identity) return;//如果该连接器的身份不是客户端则退出
player = new Socket(address, PORT);
recieveData(player.getInputStream());
out = new ObjectOutputStream(player.getOutputStream());
}

/**
 * 当需要重新连接或等待的时候重置属性
 * @throws IOException
 */
public void reset() {
try { recieveThread.interrupt(); } catch(Exception e) {}
try { player.close(); } catch(Exception e) {}
try { server.close(); } catch(Exception e) {}
}

/**
 * 发送数据给对方玩家
 * @param corres
 */
public void sendData(MutualData data) {
try {
out.writeObject(data);
} catch(Exception e) {
e.printStackTrace();
}
}

/**
 * 将接收到的数据发送给监听了该类的对象
 * @param in
 */
private void recieveData(InputStream in) {
recieveThread = new Thread(new Recieve(in));
recieveThread.start();
}

/**
 * 等待对方发送数据线程
 * @author Tomoya
 *
 */
private class Recieve implements Runnable {
private InputStream in;
public Recieve(InputStream in) {
this.in = in;
}
@Override
public void run() {
try {
ObjectInputStream ois = new ObjectInputStream(in);
while(true) {
MutualData data = (MutualData)ois.readObject();
if(recieve != null) {
recieve.recieveData(data);
}
}
} catch(ClassNotFoundException cnfe) {
cnfe.printStackTrace();
JOptionPane.showMessageDialog(null, cnfe.getMessage());
} catch(IOException ioe) {
recieve.recieveData(new MutualData(new SimpleMessage(SimpleMessage.EXIT)));//给GM发送一个对方已经退出的消息
GameConnector.this.close();//对方玩家已经退出，初始化连接设置
GameConnector.this.acceptPlayer();//重新等待玩家进入
}
}
}}