diff --git a/src/org/jgroups/protocols/Locking.java b/src/org/jgroups/protocols/Locking.java
index cc8b7a7..0f3cad6 100644
--- a/src/org/jgroups/protocols/Locking.java
+++ b/src/org/jgroups/protocols/Locking.java
@@ -1,6 +1,26 @@
 package org.jgroups.protocols;
 
-import org.jgroups.*;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+
+import org.jgroups.Address;
+import org.jgroups.Event;
+import org.jgroups.Header;
+import org.jgroups.Message;
+import org.jgroups.View;
 import org.jgroups.annotations.ManagedOperation;
 import org.jgroups.annotations.Property;
 import org.jgroups.blocks.locking.LockInfo;
@@ -10,15 +30,6 @@ import org.jgroups.stack.Protocol;
 import org.jgroups.util.Streamable;
 import org.jgroups.util.Util;
 
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.util.*;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-
 
 
 /**
@@ -594,14 +605,15 @@ abstract public class Locking extends Protocol {
 
         public void lock() {
             try {
-                acquire();
+                acquire(false);
             }
             catch(InterruptedException e) {
+                // This should never happen
             }
         }
 
         public void lockInterruptibly() throws InterruptedException {
-            acquire();
+            acquire(true);
         }
 
         public boolean tryLock() {
@@ -643,12 +655,35 @@ abstract public class Locking extends Protocol {
             lockGranted();
         }
 
-        protected synchronized void acquire() throws InterruptedException {
+        protected synchronized void acquire(boolean throwInterrupt) throws InterruptedException {
             if(!acquired) {
                 owner=getOwner();
                 sendGrantLockRequest(name, owner, 0, false);
-                while(!acquired)
-                    this.wait();
+                boolean interrupted = false;
+                while(!acquired) {
+                    try {
+                        this.wait();
+                    }
+                    catch (InterruptedException e) {
+                        // If we haven't acquired the lock yet and were 
+                        // interrupted, then we have to clean up the lock 
+                        // request and throw the exception
+                        if (throwInterrupt && !acquired) {
+                            _unlock(true);
+                            throw e;
+                        }
+                        // If we did get the lock then we will return with the
+                        // lock and interrupt status.
+                        //
+                        // If we don't throw exceptions then we just set the 
+                        // interrupt flag and let it loop around
+                        interrupted = true;
+                    }
+                }
+                
+                if (interrupted) {
+                    Thread.currentThread().interrupt();
+                }
             }
         }
 
@@ -676,6 +711,7 @@ abstract public class Locking extends Protocol {
                 sendGrantLockRequest(name, owner, timeout, true);
 
                 long target_time=use_timeout? System.currentTimeMillis() + timeout : 0;
+                boolean interrupted = false;
                 while(!acquired && !denied) {
                     if(use_timeout) {
                         long wait_time=target_time - System.currentTimeMillis();
@@ -683,11 +719,36 @@ abstract public class Locking extends Protocol {
                             break;
                         else {
                             this.timeout=wait_time;
-                            this.wait(wait_time);
+                            try {
+                                this.wait(wait_time);
+                            }
+                            catch (InterruptedException e) {
+                                // If we were interrupted and haven't received
+                                // a response yet then we try to clean up the
+                                // lock request and throw the exception
+                                if (!acquired && !denied) {
+                                    _unlock(true);
+                                    throw e;
+                                }
+                                // In the case that we were told if we acquired
+                                // or denied the lock then return that, but
+                                // make sure we set the interrupt status
+                                interrupted = true;
+                            }
                         }
                     }
-                    else
-                        this.wait();
+                    else {
+                        try {
+                            this.wait();
+                        }
+                        catch (InterruptedException e) {
+                            interrupted = true;
+                        }
+                    }
+                }
+                
+                if (interrupted) {
+                    Thread.currentThread().interrupt();
                 }
             }
             if(!acquired || denied)
