Java 扩展服务器代码，使服务器能够使用多线程与客户端交互。因此，连接到同一服务器的客户端数

*我想不出上面的问题。我已经尝试过oracle教程并注意到，但是我仍然无法做到这一点。任何帮助都将不胜感激

Blackboard上提供的权重转换服务器（ConversionServerNoConcurrency.java）可以与多个 客户端，但仅以顺序方式（即，新客户端实例只能在服务器运行后连接到服务器） 已完成与上一个客户的处理）。 扩展/修改给定的服务器代码，以便服务器能够与多个客户端并行（并发）交互， 使用多线程。同时连接到同一服务器的客户端数量不应受到限制

真的需要一些代码方面的帮助，因为其他方面，我在做作业时无法将其包含在内

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class ConversionServerNoConcurrency {
private Socket s;
private Scanner in;
private PrintWriter out;
public static void main(String[] args) throws IOException {

    ServerSocket server = new ServerSocket(8888);

    ConversionServerNoConcurrency serverInstance = new         ConversionServerNoConcurrency();

    System.out.println("Server running. Waiting for a client to connect...");

    while (true) {

        serverInstance.s = server.accept();

        System.out.println("Client connected");

        serverInstance.run();

        System.out.println("Client disconnected. Waiting for a new client to connect...");
    }
}
public void run() {
    try {
        try {

            in = new Scanner(s.getInputStream());

            out = new PrintWriter(s.getOutputStream());

            doService(); 

        } finally {
            s.close();
        }
    } catch (IOException e) {
        System.err.println(e);
    }
}
public void doService() throws IOException {

    while (true) {

        if (!in.hasNext())
            return;

        String request = in.next();

        System.out.println("Request received from client: \'" + request + "\'");

        if (!request.equals("QUIT")) // end connection with this client 
            handleConversionRequest(request);

    }
}
public void handleConversionRequest(String request) {

    String amountStr = in.next();

    double amount = Double.valueOf(amountStr);

    System.out.println("Amount received from client: " + amount);

    if (request.equals("CONVERT_TO_POUNDS")) {
        out.println(amount * 2.2d); // send conversion result to client
        System.out.println("Sent conversion result to client");
    } else if (request.equals("CONVERT_TO_KGS")) {
        out.println(amount / 2.2d); 
        System.out.println("Sent conversion result to client");
    } else
        System.err.println("Unknown request!");

       out.flush();
     }
}

---

编写面向并发连接的服务器是计算机科学/软件工程中的一个重要课题。因此，即使您不知道如何编码，也必须理解以下内容

在迭代的面向连接的服务器中，就像您拥有的

ConversionServerNoConcurrency

一样，它只有一个线程（主线程）接收连接和服务连接

如果要开发面向并发连接的服务器，需要将接收连接和服务连接分离为两个不同的线程

如果您看到下面的

ConversionServerConcurrency

，则连接接收由主线程完成，它将连接服务委托给

execService

池中的线程。使用线程池来避免DDoS攻击非常重要。因为对于线程池，可以生成的线程数量有一个最大限制

请看一下

ConversionServerTask

，它现在拥有所有服务连接的逻辑

import java.io.*;
import java.net.*;
import java.util.Scanner;
import java.util.concurrent.*;
public class ConversionServerConcurrency {

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

    ServerSocket server = new ServerSocket(8888);

    System.out.println("Server running. Waiting for a client to connect...");

    ExecutorService execService = Executors.newFixedThreadPool(10);

    while (true) {

        Socket clientSocket = server.accept();

        execService.submit(new ConversionServerTask(clientSocket));

        System.out.println("Waiting for a new client to connect...");
    }
}

public static class ConversionServerTask implements Runnable {
    private Socket s;
    private Scanner in;
    private PrintWriter out;

    public ConversionServerTask(Socket clientSocket) {
        this.s = clientSocket;
    }


    public void run() {
        System.out.println("Client connected");
        try {
            try {

                in = new Scanner(s.getInputStream());

                out = new PrintWriter(s.getOutputStream());

                doService();

            } finally {
                s.close();
            }
        } catch (IOException e) {
            System.err.println(e);
        } finally {
            System.out.println("Client disconnected");
        }
    }
    public void doService() throws IOException {

        while (true) {

            if (!in.hasNext())
                return;

            String request = in.next();

            System.out.println("Request received from client: \'" + request + "\'");

            if (request.equals("QUIT")) {// end connection with this client 
                break;
            } else {
                handleConversionRequest(request);
            }

        }
    }
    public void handleConversionRequest(String request) {

        String amountStr = in.next();

        double amount = Double.valueOf(amountStr);

        System.out.println("Amount received from client: " + amount);

        if (request.equals("CONVERT_TO_POUNDS")) {
            out.println(amount * 2.2d); // send conversion result to client
            System.out.println("Sent conversion result to client");
        } else if (request.equals("CONVERT_TO_KGS")) {
            out.println(amount / 2.2d);
            System.out.println("Sent conversion result to client");
        } else
            System.err.println("Unknown request!");

        out.flush();
    }
}


}

---

即使在这个网站上，也有成千上万的多线程服务器的例子。你必须有Java版本1.7+

import java.io.*;
import java.net.*;
import java.util.Scanner;
import java.util.concurrent.*;
public class ConversionServerConcurrency {

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

    ServerSocket server = new ServerSocket(8888);

    System.out.println("Server running. Waiting for a client to connect...");

    ExecutorService execService = Executors.newFixedThreadPool(10);

    while (true) {

        Socket clientSocket = server.accept();

        execService.submit(new ConversionServerTask(clientSocket));

        System.out.println("Waiting for a new client to connect...");
    }
}

public static class ConversionServerTask implements Runnable {
    private Socket s;
    private Scanner in;
    private PrintWriter out;

    public ConversionServerTask(Socket clientSocket) {
        this.s = clientSocket;
    }


    public void run() {
        System.out.println("Client connected");
        try {
            try {

                in = new Scanner(s.getInputStream());

                out = new PrintWriter(s.getOutputStream());

                doService();

            } finally {
                s.close();
            }
        } catch (IOException e) {
            System.err.println(e);
        } finally {
            System.out.println("Client disconnected");
        }
    }
    public void doService() throws IOException {

        while (true) {

            if (!in.hasNext())
                return;

            String request = in.next();

            System.out.println("Request received from client: \'" + request + "\'");

            if (request.equals("QUIT")) {// end connection with this client 
                break;
            } else {
                handleConversionRequest(request);
            }

        }
    }
    public void handleConversionRequest(String request) {

        String amountStr = in.next();

        double amount = Double.valueOf(amountStr);

        System.out.println("Amount received from client: " + amount);

        if (request.equals("CONVERT_TO_POUNDS")) {
            out.println(amount * 2.2d); // send conversion result to client
            System.out.println("Sent conversion result to client");
        } else if (request.equals("CONVERT_TO_KGS")) {
            out.println(amount / 2.2d);
            System.out.println("Sent conversion result to client");
        } else
            System.err.println("Unknown request!");

        out.flush();
    }
}


}