我的套接字连接是否丢失了一些通过它发送的数据？

Question

I'm writing a Connection class that sends and receives data going both ways via Command s and CommandResult s. However, when multiple requests are sent quickly over the Connection , some do not make it through properly.

It sound like a race condition of sorts, but I feel like I've prepared for that by:

• Locking and unlocking writes to the socket,
• having a table of sent Command s whose CommandResult s haven't been received,
• and locking and unlocking changes to said table.

Command s are received and processed on a single thread, so that shouldn't be the issue.

I've looked over the code enough times that I feel like the problem has to be elsewhere, but my team is very confident that Connection is the culprit.

This sample is a little long, but this was as small as I feel I could make a complete example. I did make sure it was well documented though. The important things to know are:

• AwaitWrapper s are just a Future. Getting the resource will block until it is actually filled in,
• Message s just wrap requests and responses,
• a Serializer is basically a gson wrapper,
• Command s and CommandResult s are tracked with a common UUID,
• and ICommandHandler s take in a Command and output a CommandResult . The contents of Command s and CommandResult s shouldn't matter for this.

Connection.java:

public class Connection {

    private Socket socket;
    private ICommandHandler handler;
    private Serializer ser;
    private Lock resultsLock;
    private Lock socketWriteLock;
    private Map<UUID,AwaitWrapper<CommandResult>> reservations;

    public Connection(Socket socket) {
        ser = new Serializer();
        reservations = new TreeMap<UUID,AwaitWrapper<CommandResult>>();
        handler = null;
        this.socket = socket;

        // Set up locks
        resultsLock = new ReentrantLock();
        socketWriteLock = new ReentrantLock();
    }

    public Connection(String host, int port) throws UnknownHostException, IOException {
        socket = new Socket(host, port);
        ser = new Serializer();
        reservations = new TreeMap<UUID,AwaitWrapper<CommandResult>>();
        handler = null;

        // Set up locks
        resultsLock = new ReentrantLock(true);
        socketWriteLock = new ReentrantLock(true);
    }


    /* Sends a command on the socket, and waits for the response
     *
     * @param com The command to be sent
     * @return The Result of the command operation.
     */
    public CommandResult sendCommand(Command com) {
        try {
            AwaitWrapper<CommandResult> delayedResult = reserveResult(com);
            write(new Message(com));

            CommandResult res = delayedResult.waitOnResource();
            removeReservation(com);
            return res;

        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /* Sets handler for incoming Commands. Also starts listening to the socket
     *
     * @param handler The handler for incoming Commands
     */
    public void setCommandHandler(ICommandHandler handler) {
        if (handler == null) return;
        this.handler = handler;
        startListening();
    }

    /* Starts a thread that listens to the socket
     *
     * Note: don't call this until handler has been set!
     */
    private void startListening() {
        Thread listener = new Thread() {
            @Override
            public void run() {
                while (receiveMessage());
                handler.close();
            }
        };
        listener.start();
    }

    /* Recives all messages (responses _and_ results) on a socket
     *
     * Note: don't call this until handler has been set!
     *
     * @return true if successful, false if error
     */
    private boolean receiveMessage() {
        InputStream in = null;
        try {
            in = socket.getInputStream();

            Message message = (Message)ser.deserialize(in, Message.class);
            if (message == null) return false;

            if (message.containsCommand()) {
                // Handle receiving a command
                Command com = message.getCommand();
                CommandResult res = handler.handle(com);
                write(new Message(res));

            } else if (message.containsResult()) {
                // Handle receiving a result
                CommandResult res = message.getResult();
                fulfilReservation(res);
            } else {
                // Neither command or result...?
                return false;
            }

        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }


    //--------------------------
    // Thread safe IO operations

    private void write(Message mes) throws IOException {
        OutputStream out = socket.getOutputStream();
        socketWriteLock.lock();
        ser.serialize(out, mes);
        socketWriteLock.unlock();
    }


    //----------------------------------
    //Thread safe reservation operations

    private AwaitWrapper<CommandResult> reserveResult(Command com) {
        AwaitWrapper<CommandResult> delayedResult = new AwaitWrapper<CommandResult>();

        resultsLock.lock();
        reservations.put(com.getUUID(), delayedResult);
        resultsLock.unlock();

        return delayedResult;
    }

    private void fulfilReservation(CommandResult res) {
        resultsLock.lock();
        reservations.get(res.getUUID()).setResource(res);
        resultsLock.unlock();
    }

    private void removeReservation(Command com) {
        resultsLock.lock();
        reservations.remove(com.getUUID());
        resultsLock.unlock();
    }


    //-------------------------------------------------------------------
    // A Message wraps both commands and results for easy deserialization

    private class Message {
        ...
    }
}

When monitoring the receiving side of the Connection , the handler never gets triggered for some of the Command s sent. It should be triggered by and process every incoming Command .

I'm considering ditching the reservation table and locking writes to the socket until the the response has been received, but I'm expecting that that won't come without significant performance penalties.

Am I missing some crucial step that would prevent race conditions?

---

EDIT: Adding the Serializer and ICommandHandler classes for those who are curious.

Serializer.java:

public class Serializer {

    private Gson gson;

    public Serializer() {
        gson = new Gson();
    }

    public Object deserialize(InputStream is, Class type) throws IOException {
        JsonReader reader = new JsonReader(new InputStreamReader(is, StandardCharsets.UTF_8));
        reader.setLenient(true);
        if (reader.hasNext()) {
            Object res = gson.fromJson(reader, type);
            return res;
        }
        return null;
    }

    public void serialize(OutputStream os, Object obj) throws IOException {
        JsonWriter writer = new JsonWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8));
        gson.toJson(obj, obj.getClass(), writer);
        writer.flush();
    }
}

ICommandHandler:

public interface ICommandHandler {
    public CommandResult handle(Command com);
    public void close();
}

Answer 1

The locks do nothing in your case, there is no race-condition there, if the same handler is used for multiple sockets then the locks need to be inside the handler, you're using a single-threaded client so locks do nothing there, Note: when using locks use a try-finally . If you're just starting with Sockets you probably don't know this but SocketChannel is a lot more efficient than the Socket class which is extremely old. I can't help you more than that without seeing Serializer and ICommandHandler . It is most likely a problem in the Serializer .