Java并发插座编程

Question

以下是我的简单并发服务器的代码。每当我运行多个客户端时，服务器都只会打印出第一个客户端的输入。我不确定我做错了什么。任何帮助，将不胜感激。

public static void main(String[] args) {
    try {
        ServerSocket serverSocket = new ServerSocket(8001);
        while (true){
            Socket clientSocket = serverSocket.accept();
            System.out.println(clientSocket);
            ConcurrentServer client = new ConcurrentServer(clientSocket);
            client.start();
        }
    } catch (IOException i){}
}
public void run(){
    try {
        inputStream = new BufferedReader(new InputStreamReader(concurrentSocket.getInputStream()));
        outputStream = new PrintWriter(new OutputStreamWriter(concurrentSocket.getOutputStream()));
        String testString = inputStream.readLine();
        System.out.println(testString);

    } catch (IOException i){}
}

Answer 1

此代码可能会帮助您了解如何同时运行多个客户端。:)

此代码有什么作用？ TCP客户端将字符串发送到服务器，而TCP服务器以大写格式发送了字符串＆amp;服务器可以通过多个连接同时执行此操作。

i有包括3 服务器的文件，还有一个用于测试具有多个客户端(clienttest.java(的服务器

main.java

import java.io.IOException;
public class Main {
    public static void main(String[] args) {
        try {
            new Server(3000).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

server.java

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Logger;
public class Server {
    private ServerSocket sSocket;
    private boolean run;
    private int port;
    public Server(int port) throws IOException {
        this.port = port;
        this.sSocket = new ServerSocket(this.port);
    }
    public void start() {
        this.run = true;
        Logger.getLogger(getClass().getName()).info("Server is listening on port: " + port);
        try {
            while (run) {
                Socket cs = sSocket.accept();
                Logger.getLogger(getClass().getName())
                        .info("New Client Connected! " + cs.getPort());
                new Thread(new Client(cs)).start(); // Put to a new thread.
            }
        } catch (IOException e) {
            Logger.getLogger(getClass().getName()).severe(e.getMessage());
        }
    }
    public void stop() {
        this.run = false;
    }
}

client.java (服务器上的客户端进程(

import java.io.*;
import java.net.Socket;
import java.util.logging.Logger;
public class Client implements Runnable {
    private Socket clientSocket;
    private DataOutputStream out; // write for the client
    private BufferedReader in; // read from the client
    public Client(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }
    @Override
    public void run() {
        // Do client process
        outToClient(inFromClient().toUpperCase());
        closeConnection();
    }
    private String inFromClient() {
        String messageFromClient = "";
        /*
         *  Do not use try with resources because once -
         *  - it exits the block it will close your client socket too.
         */
        try {
            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            messageFromClient = in.readLine();
        } catch (IOException e) {
            Logger.getLogger(getClass().getName()).severe("InFromClientErr - " + e.getMessage());
        }
        return messageFromClient.trim().equals("") ? "No Inputs given!" : messageFromClient;
    }
    private void outToClient(String message) {
        try {
            out = new DataOutputStream(clientSocket.getOutputStream());
            out.writeBytes(message);
        } catch (IOException e) {
            Logger.getLogger(getClass().getName()).severe("OutToClientErr - " + e.getMessage());
        }
    }
    private void closeConnection() {
        try {
            in.close();
            out.close();
            clientSocket.close();
        } catch (NullPointerException | IOException e) {
            Logger.getLogger(getClass().getName()).severe(e.getMessage());
        }
    }
}

clienttest.java (用于测试客户端(

import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class ClientTest {
    public static void main(String[] args) {
        Socket clientSocket;
        try {
            clientSocket = new Socket("localhost", 3000);
            DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
            BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            outToServer.writeBytes(new Scanner(System.in).nextLine() + 'n'); // Get user input and send.
            System.out.println(inFromServer.readLine()); // Print the server response.
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Answer 2

这个问题是与客户端一起。不是服务器。该插座被声明在for循环之外，因此仅建立了一个连接。如下所示：

public static void main(String[] args) {
    try {
        socket = new Socket("127.0.0.1", 8001);
        for (int i = 0; i < 5; i++){
            System.out.println("Starting client: " + i);
            ConcurrentClient concurrentClient = new ConcurrentClient(socket, i);
            concurrentClient.run();
        }
    } catch (IOException io) {
    }
}

应该在for循环中声明插座：

public static void main(String[] args) {
    try {
        for (int i = 0; i < 5; i++){
            socket = new Socket("127.0.0.1", 8001);
            System.out.println("Starting client: " + i);
            ConcurrentClient concurrentClient = new ConcurrentClient(socket, i);
            concurrentClient.run();
        }
    } catch (IOException io) {
    }
}

Answer 3

我真的不知道为什么您需要输入和输出流的复杂结构。最好使用将等待新输入的扫描仪。另外，您可以使用Printwriter输出对话的结果。

这是接受多个客户端的服务器：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class ConcurrentServer extends Thread {
private Socket concurrentSocket;
public ConcurrentServer(Socket clientSocket) {
    this.concurrentSocket = clientSocket;
}
public static void main(String[] args) {
    try {
        ServerSocket serverSocket = new ServerSocket(8001);
        while (true){
            Socket clientSocket = serverSocket.accept();
            System.out.println(clientSocket);
            ConcurrentServer client = new ConcurrentServer(clientSocket);
            client.start();
        }
    } catch (IOException i){}
}
public void run(){
    try {
        InputStream inputStream = concurrentSocket.getInputStream();
        Scanner scanner = new Scanner(inputStream);
        OutputStream outputStream = concurrentSocket.getOutputStream();
        PrintWriter pw = new PrintWriter(outputStream);
        while(scanner.hasNextLine()){
            String line = scanner.nextLine();
            System.out.println(line);
            pw.println("message: " + line);
            pw.flush();
        }
    } catch (IOException i){}
}

}