如何使用java套接字编程在单个客户端和服务器之间通过并行连接进行多个文件传输？

这里是单个客户机和服务器之间的并行连接。 假设我有5个文件，希望通过并行连接同时发送它们，如下图所示

在下面的代码中，我尝试实现创建2个连接，并尝试通过这2个连接发送2个文件。但是我的代码没有按预期工作。 我需要任何人的帮助来完成我的工作

服务器代码：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static String dir = "E:\\DestinatioFolder\\";

    public static void main(String[] args) throws IOException {
        ServerSocket[] servsock = new ServerSocket[5];
        Socket[] sockets = new Socket[5];


        for(int i=0;i<2;i++) {
            servsock[i] = new ServerSocket(5050+i);
            sockets[i] = servsock[i].accept();
            System.out.println("New Connection....");
        }
        int i=0;
        while(i<2) {
            BufferedInputStream bis = new BufferedInputStream(sockets[i].getInputStream());
            DataInputStream dis = new DataInputStream(bis);
            Thread t = new ClientHandler(sockets[i++], bis, dis);
            t.start();
        }
    }
}

class ClientHandler extends Thread {
    final String dir = "E:\\DestinationFolder\\";  // you may change this
    final BufferedInputStream bis;
    final DataInputStream dis;
    final Socket socket;
    public ClientHandler(Socket socket, BufferedInputStream bis, DataInputStream dis ) {
        this.socket = socket;
        this.bis = bis;
        this.dis = dis;
    }

    @Override
    public void run() {
                try{
                    long fileLength = dis.readLong();
                    String fileName = dis.readUTF();

                    System.out.println("FILE Name: "+fileName);

                    File file = new File(dir + fileName);

                    FileOutputStream fos = new FileOutputStream(file);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);

                    for (int j = 0; j < fileLength; j++) {
                        int b = bis.read();
                        bos.write(b);
                    }
                    bos.close();
                } catch(Exception e){
                    System.out.println("Server: "+e);
                } finally {
                try {
                    System.out.println("Connect closed.");
                    if(dis != null) dis.close();
                    if(socket != null) socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

import java.io.*;
import java.net.Socket;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Client {
    private static String dir = "E:\\SourceFolder\\";

    public static void main(String[] args) throws IOException, InterruptedException {
        Socket[] sock = new Socket[5];
        for(int i=0;i<2;i++) {
            sock[i] = new Socket("localhost",5050+i);
        }
        File[] files = new File(dir).listFiles();
        sendFile(files,sock);
    }

    private static void sendFile(File[] files, Socket[] sock) throws InterruptedException, IOException {

        for(int i=0;i<2;i++) {
            BufferedOutputStream bos = new BufferedOutputStream(
                    sock[i].getOutputStream());
            DataOutputStream dos = new DataOutputStream(bos);
            Thread t = new ClientThread(files[i], bos, dos);
            t.start();
        }
    }
}

class ClientThread extends Thread {
    final BufferedOutputStream bos;
    final DataOutputStream dos;
    final File file;

    public ClientThread(File file, BufferedOutputStream bos, DataOutputStream dos) {
        this.dos = dos;
        this.bos = bos;
        this.file = file;
    }

    @Override
    public void run() {

        try {
            long length = file.length();
            dos.writeLong(length);
            String fileName = file.getName();
            System.out.println("FILE: "+fileName);
            dos.writeUTF(fileName);

            FileInputStream fis = new FileInputStream(file);
            BufferedInputStream bis = new BufferedInputStream(fis);

          
            for (int j = 0; j < length; j++) {
                int b = bis.read();
                bos.write(b);
            }
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*；
导入java.net.ServerSocket；
导入java.net.Socket；
公共类服务器{
私有静态字符串dir=“E:\\destinationofolder\\”；
公共静态void main（字符串[]args）引发IOException{
ServerSocket[]servsock=新的ServerSocket[5]；
插座[]插座=新插座[5]；
对于（int i=0；i您的问题有点困惑。您真的想降低吞吐量吗？在任何情况下，只有一个网络。通过它使用多个连接都不会以任何方式严重影响吞吐量，除非传输的文件非常小。我也看不到您的方法有什么好处，但是，回到问题上来，yo你有一个多线程服务器和一个单线程单套接字客户端，所以你在代码中只打开一个连接。“一个连接的多个并行连接”在术语上是矛盾的。除非他要求你实现一个叠加的多路复用协议？我建议你在你的问题中公布分配的实际措辞n、 不是你认为它的意思。关于“独立连接”，我的实现是正确的还是需要修改？它正在工作，但我不知道我的实现是否基于独立连接。这就是为什么问。谢谢你的时间。