请教怎样关闭服务器端的socket?

Question

在主程序中设置一个结束标志，并且处理socket的thread.run可以访问到此标志，如果想结束可以通过这个标志通知 thread.run来结束。

Answer 1

可以通过在服务器端对打开的socket连结数判断当前是否有客户端连接

Answer 2

//main
Vector vec4Sock = new Vector();   // or use other collection such as hashtable
...
//pass the parameters and the vec4Sock into the Thread
...
socketInThread = vec4Sock.getNext();
//if socket can be close
  //close socketInThread//inside the thread
   // ....
   // mySocket = socket(...);
   // vec4Sock.add(mySocket);

Answer 3

to zych72(闹闹):
你的意思是在thread.run里面不停的判断那个标志？

Answer 4

import java.io.*;
import java.util.*;
import java.net.*;class TCPCCSocket extends Thread 
{
   private Socket CCSocket;
   TCPCCSocket (Socket cs) 
   {
      CCSocket = cs;
   }
   public void start() 
   {
      System.out.println("Starting CCS...");
      super.start();
   }
   public void closeSocket() 
   {
      try 
      {
         System.out.println("Close CCS...");
         super.stop();
         CCSocket.close();
      }
      catch(IOException exClose) 
      {
         System.out.println("Error When Close CCS ...");
         exClose.printStackTrace();
      }
   }
   public void run() 
   {
      System.out.println("Running CCS...");
      System.out.println(toString());
      byte[] readingByte = { 0 };
      try 
      {
         while(readingByte[0] != -1) 
         {
            readingByte[0] = (byte)CCSocket.getInputStream().read();
            CCSocket.getOutputStream().write(readingByte[0]);
         }
      }
      catch(IOException exEcho) 
      {
         System.out.println("Error When Echo CCS ...");
      }
      try 
      {
         CCSocket.close();
      }
      catch(IOException exClose) 
      {
         System.out.println("Error When Close CCS ...");
         exClose.printStackTrace();
      }
      System.out.println("End Running CCS...");
      super.stop();
   }
}

Answer 5

import java.io.*;
import java.util.*;
import java.net.*;class TCPServerSocketThread extends Thread 
{
   private static ServerSocket ListeningSocket;
   private Vector CCSArray;
   private int CCSCount;
   private static int SocketsCount;
   private static int LPort;
   private Socket tmpCCS;   TCPServerSocketThread (Vector targetSocketArr, int ListenPort) 
   {
      ListeningSocket = null;
      SocketsCount = 0;
      if(ListenPort > 1024) 
         LPort = ListenPort;
      else 
         LPort = 10000;
      CCSArray = targetSocketArr;
   }   TCPServerSocketThread (Vector targetSocketArr) 
   {
      ListeningSocket = null;
      SocketsCount = 0;
      LPort = 10000;
      CCSArray = targetSocketArr;
   }   public void stopServer() 
   {
      try 
      {
         System.out.println("Close All CCS...");
         int sockCount = CCSArray.size();
         TCPCCSocket tmpWCCS;
         while(sockCount > 0) 
         {
            tmpWCCS = (TCPCCSocket)CCSArray.elementAt((sockCount - 1));
            System.out.println("Close Next CCS...");
            if(tmpWCCS != null) 
               tmpWCCS.closeSocket();
            CCSArray.remove((sockCount - 1));
            sockCount -- ;
         }
         System.out.println("Close Server Socket...");
         ListeningSocket.close();
         SocketsCount -= 1;
         super.stop();
      }
      catch(IOException exFL) 
      {
         System.out.println("Exception On Close Server Socket...");
         exFL.printStackTrace();
      }
   }
   
   public void run() 
   {
      System.out.println("Run Server Thread...");
      System.out.println(toString());
      if(ListeningSocket == null) 
         return;
      TCPCCSocket tmpWCCS;
      while(true) 
      {
         try 
         {
            System.out.println("Server Thread Listening...");
            tmpCCS = ListeningSocket.accept();
            System.out.println(tmpCCS.toString());
            tmpWCCS = new TCPCCSocket(tmpCCS);
            CCSArray.add(tmpWCCS);
            tmpWCCS.start();
            CCSCount += 1;
         }
         catch(IOException exRL) 
         {
            System.out.println("Exception On Server Thread Listening...");
            exRL.printStackTrace();
         }
      }
   }
   public void startServer() 
   {
      System.out.println("Start Server Thread...");
      if(SocketsCount != 0) 
         return;
      SocketsCount += 1;
      try 
      {
         System.out.println("Create Server Socket...");
         ListeningSocket = new ServerSocket(LPort);
         super.start();
      }
      catch(IOException exLS) 
      {
         System.out.println("Exception On Create Server Socket...");
         exLS.printStackTrace();
      }
   }
}

Answer 6

回复人：　muchcsdn(muchdorry)　(2002-1-15 16:44:36)  得0分 
to zych72(闹闹):
你的意思是在thread.run里面不停的判断那个标志？  
是的，这样处理socket的thread可以在退出之前处理好后事