tcp server的问题

Question

我现在要完成一个功能，tcp server端，
public void run() {
     try {
        
      OutputStream os = s.getOutputStream();
      InputStream is = s.getInputStream();
      byte[] bu = new byte[20*140];
      int len = is.read(bu);
我现在要求10秒内如果接收不到客户端发来的数据，那么报错
那么如何做？是要写一个定时器程序吗？

Answer 1

我现在要完成一个功能，tcp server端， 
public void run() { 
    try { 
        
      OutputStream os = s.getOutputStream(); 
      InputStream is = s.getInputStream(); 
      byte[] bu = new byte[20*140]; 
      int len = is.read(bu); 
我现在要求10秒内如果接收不到客户端发来的数据，那么报错 
那么如何做？是要写一个定时器程序吗？

Answer 2

我现在要完成一个功能，tcp server端， 
public void run() { 
    try { 
        
      OutputStream os = s.getOutputStream(); 
      InputStream is = s.getInputStream(); 
      byte[] bu = new byte[20*140]; 
      int len = is.read(bu); 
我现在要求10秒内如果接收不到客户端发来的数据，那么报错 
那么如何做？是要写一个定时器程序吗？

Answer 3

 OutputStream os = s.getOutputStream(); 
      InputStream is = s.getInputStream(); 
      byte[] bu = new byte[20*140]; 
      int len = is.read(bu); 
wait(10);
if(len == 0)
{
   //没有收到数据的处理
}

Answer 4

可以用这个
Thread.sleep(10000);//10000代表10秒

Answer 5

我现在要求10秒内如果接收不到客户端发来的数据，那么报错       几乎不可能
socket流和文件流不太一样，文件流很容易知道文件末尾，到了文件末尾，直接就把流close掉就OK了。但是socket流不一样，你无法知道它什么时候到末尾，所以连接一直保持着，流也一直保持阻塞状态。即使用了带参数的read方法，返回了有效数据，但其实流仍然没有关闭，处于阻塞状态。

Answer 6

需要再加一个线程
private boolean serverReceivedOk;public void run() { 
    try { 
        
      OutputStream os = s.getOutputStream(); 
      InputStream is = s.getInputStream(); 
      byte[] bu = new byte[20*140];
      Thread timeChecker = new TimeCheckerThread();
      serverReceivedOk = false;
      timeChecker.start();
      int len = is.read(bu);
    }
    catch (Exception e) {} }Class TimeCheckerThread extends Thread
{
    public void run()
    {
        int timeUsed = 0;
        while (true)
        {
            if (serverReceivedOk)
            {
                break;
            }
            if (timeUsed >= timeOut)
            {
                 // show error msg
                 break;
            }
            try
            {
                Thread.sleep(1000);
            }
            catch (Exception ex){}
            timeUsed++;
        } 
    }
}

Answer 7

丢了一行最关键的private boolean serverReceivedOk;public void run() { 
    try { 
        
      OutputStream os = s.getOutputStream(); 
      InputStream is = s.getInputStream(); 
      byte[] bu = new byte[20*140];
      Thread timeChecker = new TimeCheckerThread();
      serverReceivedOk = false;
      timeChecker.start();
      int len = is.read(bu);
      serverReceivedOk = true;
    }
    catch (Exception e) {} }Class TimeCheckerThread extends Thread
{
    public void run()
    {
        int timeUsed = 0;
        while (true)
        {
            if (serverReceivedOk)
            {
                break;
            }
            if (timeUsed >= timeOut)
            {
                 // show error msg
                 break;
            }
            try
            {
                Thread.sleep(1000);
            }
            catch (Exception ex){}
            timeUsed++;
        } 
    }
}

Answer 8

import java.io.*;
import java.net.*;public class TCPServer implements Runnable { boolean success = true; public static void main(String[] args) {
new TCPServer().start();
} /*
 * 不能在静态main方法中对成员变量进行赋值所以才把所有运行代码写到start()方法里.
 */
public void start() {
try {
ServerSocket ss = new ServerSocket();
Socket s = ss.accept();
DataInputStream dis = new DataInputStream(s.getInputStream());
new Thread(new TCPServer()).start();
if (dis.read() == 0) {  // 因为这个方法是阻塞式的，所以想要主线程产生什么行为很难
if (true == success) {  // 正常读取情况下，可以do something you want

}
if (false == success) {
System.exit(0); // 改成你想要产生的行为，这里是程序退出(可以由这里写异常状况发生）
}
}
} catch (Exception e) {
e.printStackTrace();
}
} /*
 * (non-Javadoc)
 * 
 * @see java.lang.Runnable#run()
 */
public void run() {
try {
wait(10000);
success = false;
System.exit(0); // 改成你想要产生的行为，这里是程序退出（也可以由这里写异常状况发生）
} catch (InterruptedException e) {
e.printStackTrace();
} }}
怎么说呢，我这个逻辑不好，但提供了一个简单的思路，就是因为首先主线程处于阻塞状态，因此只能启动分线程去判断时间，超过时间了，分线程就提供一个布尔值来供主线程进行判断然后做出反应。 但由于主线程又是阻塞的，所以必须主线程阻塞消除了才能进行下一步的判断，所以就有两种异常处理的选择方式。基本功能应该能实现，但逻辑还有待推敲，等高人来