Question

This method notifes an event loop to start processing a message. However, if the event loop is already processing a message then, this method blocks until it receives a notification of completed event processing (which is triggered at the end of the event loop).

public void processEvent(EventMessage request) throws Exception {
    System.out.println("processEvent");

    if (processingEvent) {
        synchronized (eventCompleted) {
            System.out.println("processEvent: Wait for Event to completed");
            eventCompleted.wait();
            System.out.println("processEvent: Event completed");
        }
    }

    myRequest = request;
    processingEvent = true;
    synchronized (eventReady) {
        eventReady.notifyAll();
    }
}

This works in client mode. If I switch to server mode and the time spent in the event loop processing the message is too quick, then the method above blocks forever waiting for the event to completed. For some reason the event complete notification is sent after the processingEvent check and before the eventCompleted.wait(). It makes no difference if I remove the output statements. I can not repeat the same problem in client mode.

Why does this only happen in server mode and what can I do to prevent this happening?

Here is the eventReady wait and eventCompleted notification:

public void run() {
    try {
        while (true) {
            try {
                synchronized (eventReady) {
                    eventReady.wait();
                }
                nx.processEvent(myRequest, myResultSet);
                if (processingEvent > 0) {
                    notifyInterface.notifyEventComplete(myRequest);
                }
            } catch (InterruptedException e) {
                throw e;
            } catch (Exception e) {
                notifyInterface.notifyException(e, myRequest);
            } finally {
                processingEvent--;
                synchronized (eventCompleted) {
                    eventCompleted.notifyAll();
                }
            }
        } // End of while loop
    } catch (InterruptedException Ignore) {
    } finally {
        me = null;
    }

Here is revised code which seems to work without the deadlock problem – which BTW happened in client mode randomely after about 300 events.

private BlockingQueue<EventMessage> queue = new SynchronousQueue<EventMessage>();

public void processEvent(EventMessage request) throws Exception {
    System.out.println("processEvent");

    queue.put(request);
}


public void run() {
    try {
        while (true) {
            EventMessage request = null;
            try {
                request = queue.take();
                processingEvent = true;
                nx.processEvent(request, myResultSet);
                notifyInterface.notifyEventComplete(request);
            } catch (InterruptedException e) {
                throw e;
            } catch (Exception e) {
                notifyInterface.notifyException(e, request);
            } finally {
                if (processingEvent) {
                    synchronized (eventCompleted) {
                        processingEvent = false;
                        eventCompleted.notifyAll();
                    }
                }
            }
        } // End of while loop
    } catch (InterruptedException Ignore) {
    } finally {
        me = null;
    }
}

Answer 1

There are a number of race conditions in your code. Even declaring processingEvent volatile or using an AtomicBoolean won’t help. I would recommend using a SynchronousQueue which will block the event until the processer is ready for it. Something like:

private final BlockingQueue<Request> queue = new SynchronousQueue<Request>();
...

// this will block until the processor dequeues it
queue.put(request);

Then the event processor does:

while (!done) {
   // this will block until an event is put-ed to the queue
   Request request = queue.take();
   process the event ...
}

Only one request will be processed at once and all of the synchronization, etc. will be handled by the SynchronousQueue.