merge bug20004 into default

Author: Matthias Radestock

src/com/rabbitmq/client/impl/AMQChannel.java

@@ -49,6 +49,13 @@
  * @see Connection
  */
 public abstract class AMQChannel extends ShutdownNotifierComponent {
+    /**
+     * Private; used instead of synchronizing on the channel itself,
+     * so that clients can themselves use the channel to synchronize
+     * on.
+     */
+    public final Object _channelMutex = new Object();
+
     /** The connection this channel is associated with. */
     public final AMQConnection _connection;
 
@@ -156,19 +163,23 @@ public void handleCompleteInboundCommand(AMQCommand command) throws IOException
         }
     }
 
-    public synchronized void enqueueRpc(RpcContinuation k)
+    public void enqueueRpc(RpcContinuation k)
     {
-        if (_activeRpc != null) {
-            throw new IllegalStateException("cannot execute more than one synchronous AMQP command at a time");
+        synchronized (_channelMutex) {
+            if (_activeRpc != null) {
+                throw new IllegalStateException("cannot execute more than one synchronous AMQP command at a time");
+            }
+            _activeRpc = k;
         }
-        _activeRpc = k;
     }
 
-    public synchronized RpcContinuation nextOutstandingRpc()
+    public RpcContinuation nextOutstandingRpc()
     {
-        RpcContinuation result = _activeRpc;
-        _activeRpc = null;
-        return result;
+        synchronized (_channelMutex) {
+            RpcContinuation result = _activeRpc;
+            _activeRpc = null;
+            return result;
+        }
     }
 
     public void ensureIsOpen()
@@ -198,18 +209,22 @@ public AMQCommand rpc(Method m)
         return k.getReply();
     }
 
-    public synchronized void rpc(Method m, RpcContinuation k)
+    public void rpc(Method m, RpcContinuation k)
         throws IOException
     {
-        ensureIsOpen();
-        quiescingRpc(m, k);
+        synchronized (_channelMutex) {
+            ensureIsOpen();
+            quiescingRpc(m, k);
+        }
     }
 
-    public synchronized void quiescingRpc(Method m, RpcContinuation k)
+    public void quiescingRpc(Method m, RpcContinuation k)
         throws IOException
     {
-        enqueueRpc(k);
-        quiescingTransmit(m);
+        synchronized (_channelMutex) {
+            enqueueRpc(k);
+            quiescingTransmit(m);
+        }
     }
 
     /**
@@ -237,13 +252,13 @@ public void processShutdownSignal(ShutdownSignalException signal,
                                       boolean ignoreClosed,
                                       boolean notifyRpc) {
         try {
-            synchronized (this) {
+            synchronized (_channelMutex) {
                 if (!ignoreClosed)
                     ensureIsOpen(); // invariant: we should never be shut down more than once per instance
                 if (isOpen())
                     _shutdownCause = signal;
 
-                notifyAll();
+                _channelMutex.notifyAll();
             }
         } finally {
             if (notifyRpc)
@@ -258,33 +273,41 @@ public void notifyOutstandingRpc(ShutdownSignalException signal) {
         }
     }
 
-    public synchronized void transmit(Method m) throws IOException {
-        transmit(new AMQCommand(m));
+    public void transmit(Method m) throws IOException {
+        synchronized (_channelMutex) {
+            transmit(new AMQCommand(m));
+        }
     }
 
-    public synchronized void transmit(AMQCommand c) throws IOException {
-        ensureIsOpen();
-        quiescingTransmit(c);
+    public void transmit(AMQCommand c) throws IOException {
+        synchronized (_channelMutex) {
+            ensureIsOpen();
+            quiescingTransmit(c);
+        }
     }
 
-    public synchronized void quiescingTransmit(Method m) throws IOException {
-        quiescingTransmit(new AMQCommand(m));
+    public void quiescingTransmit(Method m) throws IOException {
+        synchronized (_channelMutex) {
+            quiescingTransmit(new AMQCommand(m));
+        }
     }
 
-    public synchronized void quiescingTransmit(AMQCommand c) throws IOException {
-        if (c.getMethod().hasContent()) {
-            while (_blockContent) {
-                try {
-                    wait();
-                } catch (InterruptedException e) {}
-                
-                // This is to catch a situation when the thread wakes up during
-                // shutdown. Currently, no command that has content is allowed
-                // to send anything in a closing state.
-                ensureIsOpen();
+    public void quiescingTransmit(AMQCommand c) throws IOException {
+        synchronized (_channelMutex) {
+            if (c.getMethod().hasContent()) {
+                while (_blockContent) {
+                    try {
+                        _channelMutex.wait();
+                    } catch (InterruptedException e) {}
+
+                    // This is to catch a situation when the thread wakes up during
+                    // shutdown. Currently, no command that has content is allowed
+                    // to send anything in a closing state.
+                    ensureIsOpen();
+                }
             }
+            c.transmit(this);
         }
-        c.transmit(this);
     }
 
     public AMQConnection getAMQConnection() {

src/com/rabbitmq/client/impl/ChannelN.java

@@ -192,7 +192,7 @@ public void releaseChannelNumber() {
                                                                          false,
                                                                          command,
                                                                          this);
-            synchronized(this) {
+            synchronized (_channelMutex) {
                 processShutdownSignal(signal, true, true);
                 quiescingTransmit(new Channel.CloseOk());
             }
@@ -248,10 +248,10 @@ public void releaseChannelNumber() {
                 return true;
             } else if (method instanceof Channel.Flow) {
                 Channel.Flow channelFlow = (Channel.Flow) method;
-                synchronized(this) {
+                synchronized (_channelMutex) {
                     _blockContent = !channelFlow.active;
                     transmit(new Channel.FlowOk(channelFlow.active));
-                    notifyAll();
+                    _channelMutex.notifyAll();
                 }
                 return true;
             } else {
@@ -329,7 +329,7 @@ public void close(int closeCode,
         try {
             // Synchronize the block below to avoid race conditions in case
             // connnection wants to send Connection-CloseOK
-            synchronized(this) {
+            synchronized (_channelMutex) {
                 processShutdownSignal(signal, !initiatedByApplication, true);
                 quiescingRpc(reason, k);
             }