问题：

多线程服务器仅从一个客户端JAVA接收数据

郝承悦

2023-03-14

public class Connection implements Runnable{
boolean isAlreadyOpened = false;

@Override
public void run() {
    // TODO Auto-generated method stub  
    try {           
        ServerSocket ss = new ServerSocket(7000);
        while(true){
            System.out.println("Il Server sta cercando Connessioni");
            Socket s = ss.accept();
            System.out.println("Il Server ha accettato un Client");

            Thread t2 = new Thread(new Runnable(){
                public void run(){             
                   try {

                        DataInputStream dis = new DataInputStream(s.getInputStream());
                        isAlreadyOpened = true;
                        DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                        while(true){
                            String test = dis.readUTF();
                            dos.writeUTF(test);
                            System.out.println(test);
                            dos.flush();
                        }                       
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        isAlreadyOpened = false;
                    }  
                }           
            });
            t2.start();
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
 }  
}

public class Connection implements Runnable {

 @Override
  public void run() {

    try {
        ServerSocket ss = new ServerSocket(7000);
        while (true) {
            System.out.println("Server is listening");
            Socket s = ss.accept();
            System.out.println("Client Accepted");

            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        DataInputStream dis = new DataInputStream(s.getInputStream());
                        DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                        while (true) {
                            String test = dis.readUTF();
                            dos.writeUTF(test);
                            System.out.println(test);
                            dos.flush();
                        }
                    } catch (IOException 
                        e.printStackTrace();
                    } finally {
                        try {
                            s.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });                 
    t2.start();
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public class Connection implements Runnable {
@Override
public void run() {
    try {
        Socket s = new Socket("127.0.0.1", 7000);
        DataInputStream dis = new DataInputStream(s.getInputStream());
        DataOutputStream dos = new DataOutputStream(s.getOutputStream());

        while(true){
           dos.writeUTF("FromAndroid");
            Log.d("InputStreammmm", dis.readUTF());
         Thread.sleep(10000)
        }

    } catch (IOException e) {
        e.printStackTrace();
    }

}

@Override
public void run() {
     try {

        Socket socket = new Socket("127.0.0.1", 7000);
        System.out.println("Connessooo");
         DataInputStream dis = new DataInputStream(socket.getInputStream());
         DataOutputStream dos = new DataOutputStream(socket.getOutputStream());

         while(true){
         dos.writeUTF("Invioooooooooooooooooooooooooo");
         result = dis.readUTF();
         System.out.println(result);
         Thread.sleep(10000);
         }

    } catch (IOException e) {

        e.printStackTrace();
    } catch (InterruptedException e) {

        e.printStackTrace();
    }
}

使用套接字列表编辑：

public class Connection implements Runnable {
List<Socket> sList = new ArrayList<>();
Socket s;
int i = 0;

@Override
public void run() {
    // TODO Auto-generated method stub
    try {
        ServerSocket ss = new ServerSocket(7000);
        while (true) {
            System.out.println("Server Listening");
            s = ss.accept();
            sList.add(s);

            System.out.println("Accepted Client --- " +s.toString());
            Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        DataInputStream dis = new DataInputStream(s.getInputStream());  

                        while (true) 
                        {
                            String test = dis.readUTF();
                            System.out.println("Message sent from -- " + sList.get(i).toString());
                            System.out.println(test);

                            while(i < sList.size()){
                                 DataOutputStream dos = new DataOutputStream(sList.get(i).getOutputStream());
                                 dos.writeUTF(test);    
                                 System.out.println("Message Sent to -- " + sList.get(i).toString());
                                 dos.flush();
                                 ++i;
                             }
                            i=0;
                        }
                    } catch (IOException e) 
                    {
                        e.printStackTrace();
                    } finally
                    {
                        try
                        {                      
                            System.out.println("Closing Socket --- " + sList.get(i).toString());
                            sList.get(i).close();
                            sList.remove(i);

                        }
                        catch (IOException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t2.start();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

}

按照EJP的建议，这样做我的问题就解决了。

共有1个答案

阙阳夏

2023-03-14

无法复制。

测试程序，从编辑过的代码中复制粘贴，并将final添加到sockets中，因为我正在使用Java7，并添加了客户端代码：

public class Connection implements Runnable
{

    @Override
    public void run()
    {

        try
        {
            ServerSocket ss = new ServerSocket(7000);
            while (true)
            {
                System.out.println("Server is listening");
                final Socket s = ss.accept();
                System.out.println("Client Accepted");

                Thread t2 = new Thread(new Runnable()
                {
                    public void run()
                    {
                        try
                        {
                            DataInputStream dis = new DataInputStream(s.getInputStream());
                            DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                            while (true)
                            {
                                String test = dis.readUTF();
                                dos.writeUTF(test);
                                System.out.println(test);
                                dos.flush();
                            }
                        }
                        catch (IOException e)
                        {
                            e.printStackTrace();
                        }
                        finally
                        {
                            try
                            {
                                s.close();
                            }
                            catch (IOException e)
                            {
                                e.printStackTrace();
                            }
                        }
                    }
                });
                t2.start();
            }
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    public static void main(String[] args) throws InterruptedException
    {
        Connection c = new Connection();
        Thread  t1 = new Thread(c);
        t1.setDaemon(true);
        t1.start();
        Runnable    r = new Runnable()
        {
            public void run()
            {
                try (Socket s = new Socket("localhost", 7000))
                {
                    DataOutputStream    dos = new DataOutputStream(s.getOutputStream());
                    DataInputStream dis = new DataInputStream(s.getInputStream());
                    for (int i = 0; i < 10; i++)
                    {
                        dos.writeUTF("Hello from "+Thread.currentThread().getName());
                        String  reply = dis.readUTF();
                        Thread.sleep(10*1000);
                    }
                }
                catch (IOException|InterruptedException exc)
                {
                    exc.printStackTrace();
                }
            }
        };
        Thread  t2 = new Thread(r);
        Thread  t3 = new Thread(r);
        t2.start();
        t3.start();
        t2.join();
        t3.join();
    }
}

输出：

Server is listening
Client Accepted
Server is listening
Client Accepted
Server is listening
Hello from Thread-1
Hello from Thread-2
Hello from Thread-2
Hello from Thread-1
Hello from Thread-2
Hello from Thread-1
Hello from Thread-2
Hello from Thread-1
Hello from Thread-1
Hello from Thread-2
Hello from Thread-1
Hello from Thread-2
Hello from Thread-2
Hello from Thread-1
Hello from Thread-1
Hello from Thread-2
Hello from Thread-2
Hello from Thread-1
Hello from Thread-2
Hello from Thread-1

类似资料：

Java TCP服务器无法从多个客户端接收消息

问题内容：我要进行最简单的解释。我的Java TCP项目有一个服务器和三个客户端。服务器具有一个ClientThread。每个客户端都有一个ServerThread和一个UserThread。工作流程为： 1.客户端（例如，client_0）的UserThread获取用户输入，然后将消息发送到服务器。 2.服务器的ClientThread捕获来自client_0的消息，并将另一条消息发送到另
Java TCP服务器无法从多个客户端接收消息

问题内容：我要进行最简单的解释。我的Java TCP项目有一个服务器和三个客户端。服务器具有一个ClientThread。每个客户端都有一个ServerThread和一个UserThread。工作流程为： 1.客户端（例如，client_0）的UserThread获取用户输入，然后将消息发送到服务器。 2.服务器的ClientThread捕获来自client_0的消息，并将另一条消息发送到另
如何在两个客户端上从服务器接收数据

我有一个客户端测试功能，它将测试对象发送到socket.io服务器，该服务器的工作是等待客户端事件，然后将数据发送到原始客户端发出事件的房间中的每个客户端。但是，只有原始客户端从服务器接收事件。房间中的其他客户端没有接收到它。我已经尝试了以及服务器端。两个客户端肯定加入同一个房间。服务器也从原始客户端接收事件。 Server.js：父组件：子组件：我希望在两个连接的客户端上读取服务器消息，
客户端服务器程序的多线程

问题内容：我正在尝试使用我一直在努力的客户端/服务器程序实现多线程。我需要允许多个客户端同时连接到服务器。我目前有4类：客户端，服务器，协议和用于处理线程的工作器。以下代码是我对这些类的拥有的代码： SocketServer类： SocketClient类别：协议类别： ClientWorker类：当我运行服务器和客户端时，一切正常。然后，当我尝试运行另一个客户端时，它只是挂在那儿，没有提示
套接字编程多个客户端到一个服务器

如何处理多个客户端连接到一个服务器？我有这个logserver.java 和一个嵌入式applet,其中包含如下所示的部分代码,例如现在的问题是，如果我在服务器上运行“Java日志服务器”，它将打开应用程序并等待输入流，如果我打开我的站点，它将开始流日志。但如果我使用其他计算机/网络再打开一个站点，第二个站点不会记录流。似乎是因为第一个仍然绑定到端口5000。我该怎么处理？socket实际上是
Java多个客户端的rmi服务器-一次只接受一个客户端调用

我正在开发一个具有多个客户端的标准java RMI服务器。这些客户机有一个菜单，在那里他们可以调用服务器为他们做各种事情。一种方法涉及一个队列，他们可以在其中将作业发送到队列并等待它得到处理。RMI服务器自动为所有客户端处理线程，但当涉及到此方法和队列时，我如何阻止此请求，例如：首先调用客户端1，然后再调用客户端2（此处客户端1应首先从服务器接收消息，客户端2应等待服务器处理客户端1请求所需的

多线程服务器仅从一个客户端JAVA接收数据

共有1个答案

相关问答

相关文章

相关阅读

相关工具

相关文档