Java-套接字需要延迟才能接收正确的数据吗？

Question

I am writing a Java program using sockets to receive data from a C program.

The C program mallocs an integer array to fit the number of elements to be put inside. For example: {111,2,2,2,3,3} (111 is just a message header), so the int[] size is 6. (We free the array after sending is completed with a return value of 0 which is success). We print out the contents of the array, everything is displayed as expected: 111,2,2,2,3,3

However, we realize that in Java, we need to add a minor delay before reading from input stream, otherwise we can't get the correct values. Eg if we don't put a Thread.sleep(2000) before input stream available, the value Java receive is like 111,0,0,0,3,3 (eg the value 2 is lost)

1) Does it affect Java if I send int array in C and ask Java to read int by int?

2) Why does the delay make the data accurate? We try playing around with 1000,1500 but only 2000 gives the most stable result

3) If in SomeAction.class, i put busy wait:

while (!pcClient.readMessage());

or

while (!pcClient.readMessage()) {}

it only go the while loop once and just break out? Whereas if I do this below , it works as intended:

while (!pcClient.readMessage()) {System.out.print("");}

Answer 1

1) Does it affect Java if I send int array in C and ask Java to read int by int?

When you ask Java to read it int by int, it basically waits for next 4 bytes available and builds an int value out of these 4 bytes

Looks like your Java client starts reading data before your C server starts writing it - that's why a delay of 2 seconds solve your problem

You can simply remove the if(dataIn.available() > 0) { } condition - dataIn.readInt() will block until the data is available on the wire

Answer 2

You're allocating and sending the wrong length. msg_queue is a pointer, and its size is irrelevant to the message length. sizeof msg_queue should be sizeof int throughout. You're sending too much data, so the receiver is getting out of sync.

Remove the pointless sleep and available() test. The subsequent reads will block for exactly the right length of time, unlike your sleep.

You don't need to clear the dynamic message befor freeing it. You don't even need to allocate the message dynamically, as its size is known at compile time.