Java 如何编写一个接受多客户端套接字的ServerSocket？_Java_Sockets_Serversocket

Java 如何编写一个接受多客户端套接字的ServerSocket？

java sockets

Java 如何编写一个接受多客户端套接字的ServerSocket？,java,sockets,serversocket,Java,Sockets,Serversocket,我正在从事套接字编程。我已经建立了这样一个服务器，应该接受多个客户端。这里我有特定数量的客户端，客户端持续每10秒向服务器发送消息，服务器必须处理它。我遇到的问题是我无法连接多个服务器，而这里的单个客户端是一个连续运行的程序，而while（true）则是这样，如果一个客户端发送请求，另一个客户端无法连接。这是我的节目服务器 public class SimpleServer extends Thread { private ServerSocket serverSocket = null;

我正在从事套接字编程。我已经建立了这样一个服务器，应该接受多个客户端。这里我有特定数量的客户端，客户端持续每10秒向服务器发送消息，服务器必须处理它。我遇到的问题是我无法连接多个服务器，而这里的单个客户端是一个连续运行的程序，而while（true）则是这样，如果一个客户端发送请求，另一个客户端无法连接。这是我的节目

服务器

public class SimpleServer extends Thread {

private ServerSocket serverSocket = null;
private Socket s1 = null;

SimpleServer() {
    try {
        serverSocket = new ServerSocket(1231);
        this.start();
    } catch (IOException ex) {
        System.out.println("Exception on new ServerSocket: " + ex);
    }
}

public void run() {
    while (true) {
        try {

            System.out.println("Waiting for connect to client");
            s1 = serverSocket.accept();
            System.out.println("Connection received from " + s1.getInetAddress().getHostName());

            InputStream s1In = s1.getInputStream();
            DataInputStream dis = new DataInputStream(s1In);

            String st = dis.readUTF();
            System.out.println(st);
            s1In.close();
            dis.close();
            s1.close();
           // throw new ArithmeticException();

        } catch (IOException ex) {
            Logger.getLogger(SimpleServer.class.getName()).log(Level.SEVERE, null, ex);
        }
         catch (Exception e) {
             System.out.println("Exceptiopn: "+e);
        }

    }
}

public static void main(String args[]) throws IOException {

    new SimpleServer();
 }
}

服务器工作正常，但我无法编写客户端程序，该程序应该在while（true）循环中运行，以便向服务器发送消息，并允许其他客户端也连接到服务器。但对于一个客户，我是这样写的

public class SimClient extends Thread {

private Socket s1 = null;

SimClient() {
    //this.start();

}

public void run() {
    int i=0;
    try {
        s1 = new Socket("localhost", 1231);
    } catch (IOException ex) {
        Logger.getLogger(SimClient.class.getName()).log(Level.SEVERE, null, ex);
    }
   // while (i<10) {
        try {
            // Open your connection to a server, at port dfg1231


            OutputStream s1out = s1.getOutputStream();
            DataOutputStream dos = new DataOutputStream(s1out);

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
             System.out.println("Enter Data from Client:");
            String s = br.readLine();
            dos.writeUTF(s);
            dos.flush();
            s1out.close();
            dos.close();
           // s1.close();
            i++;

        } catch (IOException ex) {

           //ex.printStackTrace();
            System.out.println("Exception in While: "+ex.getMessage());
        }


    //}
}

public static void main(String args[]) throws IOException {

   SimClient s= new SimClient();
   s.start();
}


 }

public类SimClient扩展线程{
私有套接字s1=null；
SimClient（）{
//这个。start（）；
}
公开募捐{
int i=0；
试一试{
s1=新套接字（“本地主机”，1231）；
}捕获（IOEX异常）{
Logger.getLogger（SimClient.class.getName（））.log（Level.SEVERE，null，ex）；
}
//虽然（i就像你有一个ServerSocket的线程一样，你需要为ServerSocket.accept（）返回的每个套接字创建一个线程，然后它立即循环回阻止并等待接受另一个套接字。创建一个名为SocketAnder的类，它扩展了线程并在构造函数中接受一个套接字
public class SocketHandler extends Thread {
    private Socket socket;

    public SocketHandler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        // use the socket here
    }
}

然后回到ServerSocket处理程序中
for (;;) {
    SocketHandler socketHander = new SocketHandler(serverSocket.accept());
    socketHander.start();
}

正如您有一个ServerSocket的线程一样，您需要为ServerSocket.accept（）返回的每个套接字创建一个线程，然后它立即循环以阻止并等待接受另一个套接字。创建一个名为SocketAnder的类，该类扩展线程并接受构造函数中的套接字
public class SocketHandler extends Thread {
    private Socket socket;

    public SocketHandler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        // use the socket here
    }
}

然后回到ServerSocket处理程序中
for (;;) {
    SocketHandler socketHander = new SocketHandler(serverSocket.accept());
    socketHander.start();
}

通常，使用固定大小的线程池是一个好主意，因为如果请求很高，以临时方式创建线程可能会导致服务器耗尽线程
public class SimpleServer extends Thread {

private ServerSocket serverSocket = null;
private static ExecutorService executor = Executors.newFixedThreadPool(100);

SimpleServer() {
    try {
        serverSocket = new ServerSocket(1231);
        this.start();
    } catch (IOException ex) {
        System.out.println("Exception on new ServerSocket: " + ex);
    }
}

public void run() {
while (true) {
    try {

        System.out.println("Waiting for connect to client");
        final Socket s1 = serverSocket.accept();
        executor.execute(new Runnable() {

            public void run() { 
                try {
                    System.out.println("Connection received from " + s1.getInetAddress().getHostName());

                    InputStream s1In = s1.getInputStream();
                    DataInputStream dis = new DataInputStream(s1In);

                    String st = dis.readUTF();
                    System.out.println(st);
                    s1In.close();
                    dis.close();
                    s1.close();
                } catch(Exception e) {
                    System.out.println("Exceptiopn: "+e);
                }
                // throw new ArithmeticException();
            }});

         } catch (IOException ex) {
                     Logger.getLogger(SimpleServer.class.getName()).log(Level.SEVERE, null, ex);
         } catch (Exception e) {
              System.out.println("Exceptiopn: "+e);
         }

}
}

public static void main(String args[]) throws IOException {

    new SimpleServer();
}
}

通常，使用固定大小的线程池是一个好主意，因为如果请求很高，以临时方式创建线程可能会导致服务器耗尽线程
public class SimpleServer extends Thread {

private ServerSocket serverSocket = null;
private static ExecutorService executor = Executors.newFixedThreadPool(100);

SimpleServer() {
    try {
        serverSocket = new ServerSocket(1231);
        this.start();
    } catch (IOException ex) {
        System.out.println("Exception on new ServerSocket: " + ex);
    }
}

public void run() {
while (true) {
    try {

        System.out.println("Waiting for connect to client");
        final Socket s1 = serverSocket.accept();
        executor.execute(new Runnable() {

            public void run() { 
                try {
                    System.out.println("Connection received from " + s1.getInetAddress().getHostName());

                    InputStream s1In = s1.getInputStream();
                    DataInputStream dis = new DataInputStream(s1In);

                    String st = dis.readUTF();
                    System.out.println(st);
                    s1In.close();
                    dis.close();
                    s1.close();
                } catch(Exception e) {
                    System.out.println("Exceptiopn: "+e);
                }
                // throw new ArithmeticException();
            }});

         } catch (IOException ex) {
                     Logger.getLogger(SimpleServer.class.getName()).log(Level.SEVERE, null, ex);
         } catch (Exception e) {
              System.out.println("Exceptiopn: "+e);
         }

}
}

public static void main(String args[]) throws IOException {

    new SimpleServer();
}
}

正如您有一个ServerSocket线程一样，您需要为ServerSocket.accept（）返回的每个套接字创建一个线程，然后它立即循环返回以阻止并等待接受另一个套接字。您可以显示一些代码片段吗..正如您有一个ServerSocket线程一样，您需要为ServerSocket.accept（）返回的每个套接字创建一个线程，然后它立即循环，以阻止并等待接受另一个套接字。您可以显示一些代码片段吗..它应该在客户端套接字中吗？在我的情况下应该是怎样的？@Raghu当您看到它时，您不识别服务器端代码？即使它包含一个ServerSocket
？并且您只是要求某人写出所有代码吗你的代码？它应该在客户端套接字中吗？在我的情况下应该是怎样的？@Raghu你看到服务器端代码时不识别它？即使它包含一个ServerSocket
？你只是要求有人为你写下所有的代码吗？谢谢你，但是如何对待客户端，我必须在我的客户端中做哪些更改没有更改客户端需要s。您问的是如何允许多个客户端同时使用服务器？谢谢，但是对于客户端，我必须对客户端进行哪些更改？客户端不需要任何更改。您问的是如何允许多个客户端同时使用服务器？