The DatagramChannel implementation does not disambiguate the case where
a received packet may contain zero bytes and the case where no packet
is actually received. This negatively impacts the scenario where the
channel is being closed asynchronously at the same time that a packet
( with zero bytes ) is being received. An exception that the channel
has been closed may be thrown instead of the received packet being
returned. This may result in data loss - e.g. the zero byte packet may
be used by a higher-level protocol as an indicator or marker of
something.

It's easy to see this with the following test:
---
    /** Tests asynchronous close when a packet with zero bytes has been received. */
    public void testUnconnectedReceive() throws Exception {
        var dc1 = DatagramChannel.open().bind(null);
        var dc2 = DatagramChannel.open();

        var address = new InetSocketAddress("localhost", dc1.socket().getLocalPort());
        out.println(format("Sending empty packet to %s", address));
        dc2.send(ByteBuffer.wrap(new byte[0]), address);

        // SM being used here since it provides a convenient means of injecting
        // close where we want it
        SecurityManager sm = new SecurityManager() {
            @Override
            public void checkAccept(String host, int port) {
                out.println(format("Allowing packet from %s:%d. Closing channel", host, port));
                try { dc1.close(); out.println("closed"); }
                catch (IOException e) { fail("UNEXPECTED", e); }
            }
            @Override
            public void checkPermission(Permission perm) { }
        };

        System.setSecurityManager(sm);
        try {
            ByteBuffer bb = ByteBuffer.allocate(10);
            SocketAddress sa = dc1.receive(bb);
            out.println(format("received from: [%s], data: [%s]", sa, bb));
            bb.flip();
            assertEquals(bb.remaining(), 0);
        } finally {
            System.setSecurityManager(null);
        }
    }
 ---