我创建了一个客户端 - 服务器连接，就像聊天系统一样。以前我在客户端使用while循环，它每次都在等待从控制台读取消息（当然服务器有while循环以及永远服务）。但是现在，我试图在会话开始时首先创建一个连接，然后偶尔在会话期间发送一条消息，以便保持永久和持久的连接。
目前，没有while循环，客户端会关闭连接，我不知道如何找到解决方法。
以下是客户端代码：
import java.net.*;
import java.io.*;
public class ControlClientTest {
private Socket socket = null;
// private BufferedReader console = null;
private DataOutputStream streamOut = null;
public static void main(String args[]) throws InterruptedException {
ControlClientTest client = null;
String IP="127.0.0.1";
client = new ControlClientTest(IP, 5555);
}
public ControlClientTest(String serverName, int serverPort) throws InterruptedException {
System.out.println("Establishing connection. Please wait ...");
try {
socket = new Socket(serverName, serverPort);
System.out.println("Connected: " + socket);
start();
} catch (UnknownHostException uhe) {
System.out.println("Host unknown: " + uhe.getMessage());
} catch (IOException ioe) {
System.out.println("Unexpected exception: " + ioe.getMessage());
}
String line = "";
// while (!line.equals(".bye")) {
try {
Thread.sleep(1000);
//TODO get data from input
// line = console.readLine();
line="1";
if(line.equals("1"))
line="1,123";
streamOut.writeUTF(line);
streamOut.flush();
} catch (IOException ioe) {
System.out.println("Sending error: " + ioe.getMessage());
}
// }
}
public void start() throws IOException {
// console = new BufferedReader(new InputStreamReader(System.in));
streamOut = new DataOutputStream(socket.getOutputStream());
}
}
这是服务器代码：
import java.awt.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class ControlServer {
private Socket socket = null;
private ServerSocket server = null;
private DataInputStream streamIn = null;
public static void main(String args[]) {
ControlServer server = null;
server = new ControlServer(5555);
}
public ControlServer(int port) {
try {
System.out
.println("Binding to port " + port + ", please wait ...");
server = new ServerSocket(port);
System.out.println("Server started: " + server);
System.out.println("Waiting for a client ...");
socket = server.accept();
System.out.println("Client accepted: " + socket);
open();
boolean done = false;
while (!done) {
try {
String line = streamIn.readUTF();
// TODO get the data and do something
System.out.println(line);
done = line.equals(".bye");
} catch (IOException ioe) {
done = true;
}
}
close();
} catch (IOException ioe) {
System.out.println(ioe);
}
}
public void open() throws IOException {
streamIn = new DataInputStream(new BufferedInputStream(
socket.getInputStream()));
}
public void close() throws IOException {
if (socket != null)
socket.close();
if (streamIn != null)
streamIn.close();
}
}
答案 0 :(得分：13)
我想总结一下我每天应用的有关TCP / IP连接稳定性的一些好的做法。
socket.setKeepAlive(true);
在一段时间不活动后自动发送信号并检查回复。保持活动间隔虽然取决于操作系统，但也有一些缺点。但总而言之，它可以提高连接的稳定性。
当您执行read（或在您的情况下为readUTF）时，您的线程实际上将永远阻止。根据我的经验，这是一种不好的做法，原因如下：关闭应用程序很困难。只是打电话给socket.close()很脏。
一个干净的解决方案，是一个简单的读取超时（例如200ms）。您可以使用setSoTimeout方法执行此操作。当read()方法超时时，它会抛出SocketTimeoutException。 （这是IOException）的子类。
socket.setSoTimeout(timeoutInterval);
以下是实现循环的示例。请注意shutdown条件。只需将其设置为true，您的线程就会平静下来。
while (!shutdown)
{
try
{
// some method that calls your read and parses the message.
code = readData();
if (code == null) continue;
}
catch (SocketTimeoutException ste)
{
// A SocketTimeoutExc. is a simple read timeout, just ignore it.
// other IOExceptions will not be stopped here.
}
}
当您经常连接需要快速处理的小命令时，请使用以下设置。
try
{
socket.setTcpNoDelay(true);
}
catch (SocketException e)
{
}
实际上还有许多尚未涵盖的副作用。
其中一个例如是旨在一次仅与1个客户端通信的服务器应用程序。有时他们接受连接甚至接受消息，但从不回复他们。
另一个问题：有时当你失去连接时，实际上可能需要很长时间才能让你的操作系统注意到这一点。可能是由于良好做法3 中描述的缺点，但在更复杂的网络情况下（例如使用RS232到以太网转换器，VMware服务器等），这种情况经常发生。
这里的解决方案是创建一个每隔x秒发送一条消息的线程，然后等待回复。 （例如每15秒）。为此，您需要创建第二个线程，每隔15秒发送一条消息。其次，您需要稍微扩展良好做法2 的代码。
try
{
code = readData();
if (code == null) continue;
lastRead = System.currentTimeMillis();
// whenever you receive the heart beat reply, just ignore it.
if (MSG_HEARTBEAT.equals(code)) continue;
// todo: handle other messages
}
catch (SocketTimeoutException ste)
{
// in a typical situation the soTimeout is about 200ms
// the heartbeat interval is usually a couple of seconds.
// and the heartbeat timeout interval a couple of seconds more.
if ((heartbeatTimeoutInterval > 0) &&
((System.currentTimeMillis() - lastRead) > heartbeatTimeoutInterval))
{
// no reply to heartbeat received.
// end the loop and perform a reconnect.
break;
}
}
您需要确定您的客户端或服务器是否应该发送消息。这个决定并不那么重要。但是例如如果您的客户端发送消息，那么您的客户端将需要一个额外的线程来发送消息。您的服务器应在收到消息时发送回复。当您的客户收到答案时，它应该只是continue（即参见上面的代码）。双方都应该检查：＆＃34;它已经存在了多长时间？＆＃34;以非常相似的方式。
答案 1 :(得分：1)
使客户端套接字连接围绕一个线程。使用blocking queue等待消息。在整个应用程序中应该只有一个发送者队列，因此请使用单例模式。
e.g。
QueueSingleton queue = QueueSingleton.getSenderQueue();
Message message = queue.take() // blocks thread
send(message); //send message to server
当您需要向服务器发送消息时，您可以使用阻止队列发送消息。
QueueSingleton queue = QueueSingleton.getSenderQueue();
queue.put(message)
客户端线程将被唤醒并处理该消息。
要维持连接，请使用timer task。这是一种特殊类型的线程，它在指定的时间段内重复调用run方法。您可以使用它来经常发布消息，ping消息。
为了处理收到的消息，你可以有另一个线程，等待另一个阻塞队列（接收队列）上的消息。客户端线程会将收到的消息放在此队列中。
答案 2 :(得分：0)
你可以在连接周围包裹一个线程并让它定期发送状态以保持线路开放，比如说每30秒或者其他什么。然后，当它实际上有数据要发送时，它会将保持活动重置为最后一次传输后30秒。状态可能有助于查看客户端是否还活着，所以至少它可以是一个有用的ping。
此外，您应该更改服务器代码，此时您似乎只处理一个连接。你应该循环，当套接字连接产生一个线程来处理客户端请求并返回监听。不过，我可能正在阅读可能只是你的测试代码的内容。