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

时间：2017-02-27 21:06:10

标签： java sockets

我正在尝试实现客户端 - 服务器通信。 我试过异步的，现在我要同步一个，但只是为了让它工作。我切断了尽可能多的不必要的代码，即使经过一天的研究，我也无法使其工作。拜托，如果你能救我，我真的很感激！

我现在将指出问题并指出代码的某些部分，了解所有代码都在下面提供

问题： 在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次Integer来流，然后我调用线程读取，然后再继续写一些。 这个测试的目的是用数据充斥套接字，好像你会在每次发送之间放置Thread.Sleep（5000），一切都会好的。

问题是，在运行时，有时读取输出不是预期的数字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，甚至是一些未初始化的值。 拜托，你能帮帮我吗？我无法解释也无法理解，地球上的这种可能性如何。 我正在使用我所使用的所有功能的红色文档，但这仍然是一个谜。

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

1 个答案:

答案 0 :(得分：1)

你正在Listen方法中启动一个调用Accept_begin的线程 - ＆gt; Accept_end - ＆gt; Accept_begin - ＆gt; ......在无限循环中。

在Accept_end中，您将继续不断更换BReaderForClient和writer。这里似乎有些不对劲。

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

相关问题
最新问题