Java socket问题

Question

service.java

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import ThreadPg.*;

public class service {

    private ServerSocket server;

    private Executor Pool;

    public static void main(String[] args) throws Exception{
        
        service ser = new service(99, 1000);

        ser.startserver();

    }

    public service(int Port,int PoolSize) {

        try {

            server = new ServerSocket(99);

            Pool = Executors.newFixedThreadPool(PoolSize);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public void startserver() {

        try {

            while(true) {

                Socket socket = server.accept();

                Pool.execute(new BgThread(socket));

            }

        } catch(Exception e) {

            e.printStackTrace();

        }

    }

    

}

BgThread.java

package ThreadPg;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.net.Socket;

public class BgThread implements Runnable{
    
    private Socket s;

    public BgThread(Socket s) {

        super();

        this.s = s;

    }

    @Override

    public void run() {

        try {

            InputStream input = s.getInputStream();

            InputStreamReader inputread = new InputStreamReader(input);

            OutputStream output = s.getOutputStream();

            char[] ch = new char[8192];

            int len;

            String rep = "Recv your Msg.";

            while((len = inputread.read(ch)) != -1) {

                String r = new String(ch,0,len);

                System.out.println("Recv: " +r);

                output.write(rep.getBytes());

                output.close();

            }

            inputread.close();

            input.close();

        } catch(Exception e) {

            e.printStackTrace();

        }

    }

}

client.java

import java.io.*;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.net.*;
import ThreadPg.*;



public class client {

    private static boolean f;

   public static void main(String[] args) throws Exception{
    
    String Address = "192.168.159.128";

    int Port = 99;

    f = true;
    
    Thread clientread = new Thread(new Runnable() {

        public void run() {

            try {

                Socket s = new Socket(Address,Port);

                InputStream input = s.getInputStream();

                byte[] ch = new byte[8192];

                int len;

                while((len = input.read(ch)) != -1) {

                    System.out.println("Recv from server: " + new String(ch,0,len));

                    s.close();

                    f = false;

                }


            } catch(Exception e) {

                e.printStackTrace();

            }

        }

    }

    );

    Thread clientwrite = new Thread(new Runnable() {

        public void run() {

            try {

                Socket s = new Socket(Address,Port);

                OutputStream output = s.getOutputStream();

                String outmess = null;

                Scanner scan = new Scanner(System.in);

                System.out.print("Msg: ");

                if(scan.hasNext()) {

                    outmess = scan.nextLine();

                }

                byte[] out = outmess.getBytes();

                output.write(out);

                output.flush();

                output.close();

                s.close();

                f = false;

                

            } catch(Exception e) {

                e.printStackTrace();

            }

        }

    });


    if(f = true) {

        clientread.start();

        clientwrite.start();

    }

    else if(f = false) {

        clientread.interrupt();

        clientwrite.interrupt();

        clientread.start();

        clientwrite.start();

    }


    

   }

}

各位博主，请问如何修改上述代码才能使客户端消息能多次发送，现在的测试效果为发送一次后服务的立即就可以接收，但客户端却不能再发送消息了。

Answer 1

引自免费微信小程序：皆我百晓生

要解决客户端只能发送一次消息的问题，关键在于确保客户端在发送完一次消息后，不立即关闭Socket连接，而是保持连接开放以便后续发送更多消息。在当前的client.java代码中，每次发送或接收消息后都会关闭Socket，这导致了无法进行后续通信。以下是修改后的代码示例，它允许客户端持续发送和接收消息，直到用户决定退出。

首先，我们需要将Socket对象从线程内部移到client类的成员变量中，这样可以确保Socket在整个客户端生命周期内保持打开状态。同时，我们将把输入流和输出流也作为成员变量处理，以便在多个读写操作之间重用它们。

下面是修改后的client.java代码：

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class client {

    private static boolean running = true;
    private static Socket socket;
    private static OutputStream output;
    private static InputStream input;

    public static void main(String[] args) throws Exception {
        String address = "192.168.159.128";
        int port = 99;

        // Establish connection once and keep it open
        socket = new Socket(address, port);
        input = socket.getInputStream();
        output = socket.getOutputStream();

        Thread clientRead = new Thread(() -> {
            byte[] buffer = new byte[8192];
            try {
                while (running) {
                    int len = input.read(buffer);
                    if (len != -1) {
                        System.out.println("Recv from server: " + new String(buffer, 0, len));
                    } else {
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                closeResources();
            }
        });

        Thread clientWrite = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            try {
                while (running) {
                    System.out.print("Msg: ");
                    String message = scanner.nextLine();
                    if ("exit".equalsIgnoreCase(message)) {
                        running = false;
                        break;
                    }
                    output.write(message.getBytes());
                    output.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                scanner.close();
                closeResources();
            }
        });

        clientRead.start();
        clientWrite.start();
    }

    private static void closeResources() {
        try {
            if (output != null) output.close();
            if (input != null) input.close();
            if (socket != null) socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个版本中，我们创建了一个共享的Socket连接，并在主线程之外启动了两个线程：一个用于读取服务器响应（clientRead），另一个用于向服务器发送消息（clientWrite）。我们还添加了一个closeResources方法来优雅地关闭所有资源，当用户输入"exit"时会触发这个方法。

通过这样的修改，客户端将能够持续与服务器通信，直到用户决定终止程序。注意，为了防止死锁，确保在所有可能的异常情况下都调用了资源关闭逻辑。