Java套接字DataInputStream读取未初始化的数据

我正在尝试实现客户机-服务器通信。 我试过异步一个，现在我绑定了同步一个，但只是为了让它工作。我尽可能地删除了不必要的代码，即使经过一天的研究，我也无法让它工作。求你了，如果你能救我，我会非常感激的

我现在将详细说明这个问题，并指出代码的一些部分，尽管下面提供了所有代码

问题是： 在main.java中

我创建一个服务器和客户端，然后发送数据

s.InitiateRead()

是一个函数，它只会永远循环并尝试从DataInputStream读取int

len = BReaderForClient.readInt();

您还可以看到如下代码

c.Send(ByteBuffer.wrap("A".getBytes()));

这只发送数字12，而不是任何A或其他什么，最终在线程中调用的方法位于ClientServerBase.java中：

void Send_Begin(ByteBuffer Data, DataOutputStream OutputStream) {
    try {
        while(CurrentlyWritingToOutputStream)
        { /* wait */ }

        CurrentlyWritingToOutputStream = true;

        OutputStream.writeInt(12);
        OutputStream.flush();

        CurrentlyWritingToOutputStream = false;

        Send_End(false);
    } catch (IOException e) {
        Send_End(true);
    }
}

如您所见，我有用于从多个线程写入的信号量

所以我将3倍整数写入流，然后调用线程中的读取，然后继续写入更多。 这个测试的目的是让套接字充满数据，就像在每次发送之间放置Thread.Sleep5000一样，一切都会正常

问题是，当运行时，有时读取输出不是预期的数字12

请注意，main.java中注释的while循环可以取消注释，仍然会给出错误的输出，只是说如果主线程结束，它将终止所有其他线程

所有代码：

main.java

package net;

import java.nio.ByteBuffer;

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

        Server s = new Server();
        s.Start();
        if(!s.Listen())
            return;


        Client c = new Client();

        c.Send(ByteBuffer.wrap("A".getBytes()));
        c.Send(ByteBuffer.wrap("A".getBytes()));
        c.Send(ByteBuffer.wrap("A".getBytes()));

        new Thread(new Runnable() {
            public void run() {
                s.InitiateRead();
            }
        }).start();

        c.Send(ByteBuffer.wrap("A".getBytes()));
        c.Send(ByteBuffer.wrap("A".getBytes()));
        c.Send(ByteBuffer.wrap("A".getBytes()));

        /*while(true)
        {}*/
    }
}

Server.java

package net;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;

public class Server extends ClientServerBase {
    public Server()
    {
        super(ClientServerBase.REAL_TYPE.SERVER);
    }

    // ======================================================================================
    void Accept_Begin() {
        Socket socket = null;
        try {
            socket = serverSocket.accept();
        } catch (IOException e) {
            Accept_End(true, socket);
            return;
        }
        Accept_End(false, socket);
    }
    public void InitiateRead()
    {
        while(true){

        int len = 0;
        try {
            len = BReaderForClient.readInt();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Print("Red: " + len);
        }
    }

    void Accept_End(boolean error, Socket acceptedclient) {
        try {
            if (!error) {
                Print("Client accepted");
                Clientsock = acceptedclient;

                BwriterForClient = new DataOutputStream(acceptedclient.getOutputStream());
                BReaderForClient = new DataInputStream(acceptedclient.getInputStream());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        Accept_Begin();
    }

    public void close() throws IOException {
        BwriterForClient.close();
        Clientsock.close();
        serverSocket.close();
    }

    public boolean Listen() {
        if(serverSocket == null)
        {
            Print("Can not listen, Start() was not called.");
            return false;
        }

        new Thread(new Runnable() {
            public void run() {
                Accept_Begin();
            }
        }).start();

        return true;
    }

    public boolean Start()
    {
        try 
        {
            serverSocket = new ServerSocket(1254);
        } 
        catch (IOException e) 
        {
            Print("Can not host, port is probably already in use");
            return false;
        }
        return true;
    }
    public void Send(ByteBuffer b) {
        Send_In_Thread(b, BwriterForClient);
    }

    Socket Clientsock;
    ServerSocket serverSocket;
    DataOutputStream BwriterForClient;
    DataInputStream BReaderForClient;
}

Client.java

package net;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;

public class Client extends ClientServerBase {
    public Client() throws UnknownHostException, IOException 
    {
        super(ClientServerBase.REAL_TYPE.CLIENT);

        ClientSocket = new Socket("localhost", 1254);
        DIS = new DataInputStream(ClientSocket.getInputStream());
        DOS = new DataOutputStream(ClientSocket.getOutputStream());

        //Read_In_Thread(DIS);
    }

    public void close() throws IOException {
        DIS.close();
        DOS.close();
        ClientSocket.close();
    }


    /**
     * @brief Sends data to the server. That is done in thread
     * @param Data
     */

    public void Send(ByteBuffer Data) {
        Send_In_Thread(Data, DOS);
    }


    Socket ClientSocket;
    DataInputStream DIS;
    DataOutputStream DOS;
}

ClientServerBase.java公共库

package net;

import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

public abstract class ClientServerBase {
    protected enum REAL_TYPE
    {
        CLIENT,
        SERVER
    }

    protected ClientServerBase(final REAL_TYPE r)
    {   
        CurrentlyWritingToOutputStream = false;
        ReadThreadRunning = false;
        real_type = r;
    }

    //=============================================================================

    protected void Print(String s)
    {
        if(real_type == REAL_TYPE.CLIENT)
            s = "Client: " + s;
        else
            s = "Server: " + s;
        System.out.println(s);
    }   

    void Send_Begin(ByteBuffer Data, DataOutputStream OutputStream) {
        try {
            while(CurrentlyWritingToOutputStream)
            { /* wait */ }

            CurrentlyWritingToOutputStream = true;

            OutputStream.writeInt(12);
            OutputStream.flush();

            CurrentlyWritingToOutputStream = false;

            Send_End(false);
        } catch (IOException e) {
            Send_End(true);
        }
    }

    void Send_End(boolean Error) {
        if (!Error)
            Print("Data sent sucessfully");
        else
            Print("There was an error sending data");
    }

    protected void Send_In_Thread(ByteBuffer Data, DataOutputStream OutputStream) {
        new Thread(new Runnable() {
            public void run() {
                Send_Begin(Data, OutputStream);
            }
        }).start();
    }

    boolean ReadThreadRunning;
    boolean CurrentlyWritingToOutputStream;
    /**
     * Real type of object
     */
    REAL_TYPE real_type;
}

程序的输出：

Server: Client accepted
Client: Data sent sucessfully
Client: Data sent sucessfully
Client: Data sent sucessfully
Server: Red: 12
Server: Red: 0
Client: Data sent sucessfully
Client: Data sent sucessfully
Server: Red: 3084
Client: Data sent sucessfully
Server: Red: 12
Server: Red: 0
Server: Red: 201326604

如您所见，有时，它读取0，甚至一些未初始化的值。 拜托，你能帮我吗？我无法解释也无法理解，这究竟是怎么可能的。 我使用了所有函数的红色文档，但这仍然是一个谜

---

非常感谢您提供的任何可能的帮助

您正在Listen方法中启动一个线程，该线程调用Accept\u begin->Accept\u end->Accept\u begin->。。。在无限循环中

在Accept_端，您将不断地为客户端和编写器替换breader。这里似乎有点不对劲

---

此外，您正在进行并行编程。您的发送方法需要同步

虽然它显然不能解决问题本身，但在Java中使用它非常有效，并且与JDK配合使用也很好。我建议坚持使用它，这里没有信号量，只有一个布尔变量，这是不够的。您应该使用同步、等待/通知或适当的信号量。是的，在侦听中我意识到了这一点，将来我希望接受更多的客户端。send方法…在我看来，应该使用布尔变量CurrentlyWritingToOutputStream充分地完成同步，因为一次只有一个线程将写入Stream…哇，非常感谢。我在谷歌上搜索了同步，发现它可以在Java中使用synchronized关键字来完成。到目前为止，当我运行程序12次时，仍然得到相同的输出。谢谢