Remove MultiLock implementation

Currently the Curses code is broken. Importing offlineimap.ui.Curses
will not succeed due to cyclic imports (threadutils imports ui, but ui
wants threadutils.MultiLock). So Curses cannot be chosen.

Incidentally, the only part in the code that uses "MultiLock" is the
Curses UI, to prevent concurrent access from several threads to the
ui-internal thread list and to IO resources such as the
screen. Fortunately for these purposes we don't need a MultiLock, so we
can do away with that implementation completely. A simple RLock that
allows us to have a thread "own" a lock and makes other threads wanting
access to the resource wait until the owning thread is finished.

The MultiLock implementation looked a bit weird, so simplifying code
here is a good thing, it might well be that we fix some "hangs" that
have been reported (and that would only ever occur with the Curses UI).

Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
Signed-off-by: Nicolas Sebrecht <nicolas.s-dev@laposte.net>

offlineimap/threadutil.py

@@ -246,54 +246,3 @@ class InstanceLimitedThread(ExitNotifyThread):
         finally:
             if instancelimitedsems and instancelimitedsems[self.instancename]:
                 instancelimitedsems[self.instancename].release()
-        
-    
-######################################################################
-# Multi-lock -- capable of handling a single thread requesting a lock
-# multiple times
-######################################################################
-
-class MultiLock:
-    def __init__(self):
-        self.lock = Lock()
-        self.statuslock = Lock()
-        self.locksheld = {}
-
-    def acquire(self):
-        """Obtain a lock.  Provides nice support for a single
-        thread trying to lock it several times -- as may be the case
-        if one I/O-using object calls others, while wanting to make it all
-        an atomic operation.  Keeps a "lock request count" for the current
-        thread, and acquires the lock when it goes above zero, releases when
-        it goes below one.
-
-        This call is always blocking."""
-        
-        # First, check to see if this thread already has a lock.
-        # If so, increment the lock count and just return.
-        self.statuslock.acquire()
-        try:
-            threadid = thread.get_ident()
-
-            if threadid in self.locksheld:
-                self.locksheld[threadid] += 1
-                return
-            else:
-                # This is safe because it is a per-thread structure
-                self.locksheld[threadid] = 1
-        finally:
-            self.statuslock.release()
-        self.lock.acquire()
-
-    def release(self):
-        self.statuslock.acquire()
-        try:
-            threadid = thread.get_ident()
-            if self.locksheld[threadid] > 1:
-                self.locksheld[threadid] -= 1
-                return
-            else:
-                del self.locksheld[threadid]
-                self.lock.release()
-        finally:
-            self.statuslock.release()