Datagram Packets sending too fast?

Question

I am testing sending UDP packets as fast as possible over a 10/100 switch. It seems my problem is actually sending to fast because when I insert a wait (1ms works) into the send routine all the packets are received. When I do not wait I seem to lose about 1%-5% of 20,000 1kB packets (during testing). It seems hard for me to believe the receive routine is doing too much work to cause packet loss because all it is doing is adding the packet to a Queue (which is really a LinkedList). Any comments on this would be very helpful. Some of my code is below:
The send routine:
public void sendAll()
// While still packets in send Queue
while(!sendQueue.empty())
// A 1ms wait here works
send((DatagramPacket)sendQueue.dequeue());
The receive routine (in the run method of a Thread):
// Create a datagram socket, bound to the specific port 2000
DatagramSocket socket = new DatagramSocket(2000);
boolean f = false;
while(!f)
// Create a datagram packet, containing a maximum buffer of 1048 bytes
     DatagramPacket packet = new DatagramPacket( new byte[1048], 1048 );
// Receive a packet - remember by default this is a blocking operation
socket.receive(packet);
// Add the received packet to the receive Queue
// This routine also checks the first byte of the packet's data to determine packet type
addToReceiveQueue(packet);
P.S. The program now does not do anything about packet loss, I will be adding some flow contol soon. If anyone knows some good links to implementation concerning sliding window/flow control for UDP a link would be great. And oh ya, I am required to use UDP - no TCP for me :)

Answer 1

use setReceiveBufferSize to sets the SO_RCVBUF option to the specified value for the DatagramSocket. The SO_RCVBUF option is used by the the network implementation as a hint to size the underlying network I/O buffers.
Increasing SO_RCVBUF may allow the network implementation to buffer multiple packets when packets arrive faster than are being received using #receive().