Java 使用不同端口号创建套接字时已在使用的地址

出于某种原因，我得到了以下异常（java.net.BindException:Address ready in use），即使我在启动一个新套接字之前增加了端口。在使用线程之前，我没有遇到这个异常

发送方应将文件的一部分（每个部分使用新的套接字）发送给接收方。程序正在运行，所有部件都是在不使用线程的情况下接收的

现在，接收方只接收文件的第一部分，因为服务器不会在第一部分之后创建任何套接字

此外，这些端口没有被使用，因为在我开始使用线程之前它们都可以工作

我是线程新手，所以我知道我可能用错了

提前谢谢

服务器类：

public class Server {
int port = 8500;

public Server(int x) {
    for (int i = 0; i < x; i++) {
        ServerThread s = new ServerThread(port);
        s.start();
        port++;
    }

}

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

    DatagramSocket socket = new DatagramSocket(7499);
    byte[] buffer = new byte[256];
    DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
    socket.receive(receivePacket);
    String message = new String(buffer, 0, receivePacket.getLength());
    int xyz = Integer.parseInt(message);
    socket.close();
    Server server = new Server(xyz);

    try {
        FileJoin f = new FileJoin();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.exit(0);
}

}

客户端类：

public class Client {

private FileEvent event1 = null;
private String sourceFilePath = "D:/workspace/newUDP/Image.jpgPart";
private int filenum;
private String destinationPath = "E:/UDPreceive/";
private int port = 8500;

private String hostName = "127.0.0.1";

public Client() {

}

public void createConnection(int x) {

    try {
        InetAddress IPAddress = InetAddress.getByName(hostName);
        for (int i = 0; i < x; i++) {
            DatagramSocket socket1 = new DatagramSocket();

            byte[] incomingData = new byte[1024];

            event1 = getFileEvent(0);

            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            ObjectOutputStream os = new ObjectOutputStream(outputStream);

            os.writeObject(event1);

            byte[] data = outputStream.toByteArray();

            DatagramPacket sendPacket1 = new DatagramPacket(data,
                    data.length, IPAddress, port);

            socket1.send(sendPacket1);

            System.out.println("File sent from client");

            DatagramPacket incomingPacket = new DatagramPacket(
                    incomingData, incomingData.length);

            socket1.receive(incomingPacket);

            String response = new String(incomingPacket.getData());

            System.out.println("Response from server:" + response);

            port++;
        }

        Thread.sleep(2000);

    } catch (UnknownHostException e) {

        e.printStackTrace();

    } catch (SocketException e) {

        e.printStackTrace();

    } catch (IOException e) {

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

        e.printStackTrace();

    }

}

public FileEvent getFileEvent(int i) {

    FileEvent fileEvent = new FileEvent();
    sourceFilePath = sourceFilePath + filenum;

    String fileName1 = sourceFilePath.substring(
            sourceFilePath.lastIndexOf("/") + 1, sourceFilePath.length());

    String path1 = sourceFilePath.substring(0,
            sourceFilePath.lastIndexOf("/") + 1);

    fileEvent.setDestinationDirectory(destinationPath, 0);

    fileEvent.setFilename(fileName1, 0);

    fileEvent.setSourceDirectory(sourceFilePath, 0);

    File file1 = new File(sourceFilePath);
    filenum++;
    sourceFilePath = "D:/workspace/newUDP/Image.jpgPart";

    if (file1.isFile()) {

        try {

            DataInputStream diStream = new DataInputStream(
                    new FileInputStream(file1));

            long len = (int) file1.length();

            byte[] fileBytes = new byte[(int) len];

            int read = 0;

            int numRead = 0;

            while (read < fileBytes.length
                    && (numRead = diStream.read(fileBytes, read,

                    fileBytes.length - read)) >= 0) {

                read = read + numRead;

            }

            fileEvent.setFileSize(len, 0);

            fileEvent.setFileData(fileBytes, 0);

            fileEvent.setStatus("Success", 0);

        } catch (Exception e) {

            e.printStackTrace();

            fileEvent.setStatus("Error", 0);

        }

    } else {

        System.out.println("path specified is not pointing to a file");

        fileEvent.setStatus("Error", 0);

    }

    return fileEvent;

}

public static void main(String[] args) throws IOException {
    try {
        FileSplit f = new FileSplit();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    try {
        DatagramSocket socket = new DatagramSocket();
        String xyz = "" + FileSplit.getJ();
        System.out.println(xyz);
        InetAddress serverAddress = InetAddress.getByName("127.0.0.1");

        byte[] sendBytes = xyz.getBytes();

        DatagramPacket sendPacket = new DatagramPacket(sendBytes,
                sendBytes.length, serverAddress, 7499);
        socket.send(sendPacket);
        System.out.println(xyz);
        Client client = new Client();

        client.createConnection(Integer.parseInt(xyz));
    } catch (IOException x) {

    }

    System.exit(0);
}

公共类客户端{
private FileEvent event1=null；
私有字符串sourceFilePath=“D:/workspace/newUDP/Image.jpgPart”；
私有int filenum；
私有字符串destinationPath=“E:/udprective/”；
专用int端口=8500；
私有字符串hostName=“127.0.0.1”；
公共客户机（）{
}
公共无效createConnection（int x）{
试一试{
InetAddress IPAddress=InetAddress.getByName（主机名）；
对于（int i=0；i=0）{
读取=读取+numRead；
}
setFileSize（len，0）；
setFileData（fileBytes，0）；
fileEvent.setStatus（“成功”，0）；
}捕获（例外e）{
e、 printStackTrace（）；
fileEvent.setStatus（“错误”，0）；
}
}否则{
System.out.println（“指定的路径未指向文件”）；
fileEvent.setStatus（“错误”，0）；
}
返回文件事件；
}
公共静态void main（字符串[]args）引发IOException{
试一试{
FileSplit f=newfilesplit（）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
DatagramSocket套接字=新DatagramSocket（）；
字符串xyz=”“+FileSplit.getJ（）；
System.out.println（xyz）；
InetAddress服务器地址=InetAddress.getByName（“127.0.0.1”）；
byte[]sendBytes=xyz.getBytes（）；
DatagramPacket sendPacket=新的DatagramPacket（sendBytes，
sendBytes.length，服务器地址，7499）；
socket.send（sendPacket）；
System.out.println（xyz）；
客户端=新客户端（）；
createConnection（Integer.parseInt（xyz））；
}捕获（IOX异常）{
}
系统出口（0）；
}

} 堆栈跟踪：

java.net.BindException: Address already in use: Cannot bind
at java.net.DualStackPlainDatagramSocketImpl.socketBind(Native Method)
at java.net.DualStackPlainDatagramSocketImpl.bind0(Unknown Source)
at java.net.AbstractPlainDatagramSocketImpl.bind(Unknown Source)
at java.net.DatagramSocket.bind(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at pack.ServerThread.createAndListenSocket(ServerThread.java:32)
at pack.ServerThread.run(ServerThread.java:24)

java.net.BindException:地址已在使用中：无法绑定
位于java.net.DualStackPlainDatagramSocketImpl.socketBind（本机方法）
位于java.net.DualStackPlainDatagramSocketImpl.bind0（未知源）
位于java.net.AbstractPlainDatagramSocketImpl.bind（未知源）
位于java.net.DatagramSocket.bind（未知源）
位于java.net.DatagramSocket。（未知源）
位于java.net.DatagramSocket。（未知源）
位于java.net.DatagramSocket。（未知源）
位于pack.ServerThread.createAndListenSocket（ServerThread.java:32）
运行（ServerThread.java:24）

这里没有使用线程。您可以在构造函数中启动服务器

当您调用

s.start（）时，您正在调用，因为它的run方法具有不同的签名，您需要重写它，而不是重载它，请参见差异

其他软件也可以使用您的端口。你需要检查它是否免费，而不仅仅是使用它

---

张贴完整的stacktrace。检查是否没有其他进程绑定到您正在尝试的端口。实际上，您没有正确使用线程：您的运行方法

java.net.BindException: Address already in use: Cannot bind
at java.net.DualStackPlainDatagramSocketImpl.socketBind(Native Method)
at java.net.DualStackPlainDatagramSocketImpl.bind0(Unknown Source)
at java.net.AbstractPlainDatagramSocketImpl.bind(Unknown Source)
at java.net.DatagramSocket.bind(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at java.net.DatagramSocket.<init>(Unknown Source)
at pack.ServerThread.createAndListenSocket(ServerThread.java:32)
at pack.ServerThread.run(ServerThread.java:24)