Initial revision

diff --git a/Lib/mutex.py b/Lib/mutex.py
new file mode 100644 (file)
index 0000000..38983fc
--- /dev/null
+++ b/Lib/mutex.py
@@ -0,0 +1,59 @@
+# Mutual exclusion -- for use with module sched
+
+# A mutex has two pieces of state -- a 'locked' bit and a queue.
+# When the mutex is not locked, the queue is empty.
+# Otherwise, the queue contains 0 or more (function, argument) pairs
+# representing functions (or methods) waiting to acquire the lock.
+# When the mutex is unlocked while the queue is not empty,
+# the first queue entry is removed and its function(argument) pair called,
+# implying it now has the lock.
+#
+# Of course, no multi-threading is implied -- hence the funny interface
+# for lock, where a function is called once the lock is aquired.
+#
+class mutex():
+       #
+       # Create a new mutex -- initially unlocked
+       #
+       def init(self):
+               self.locked = 0
+               self.queue = []
+               return self
+       #
+       # Test the locked bit of the mutex
+       #
+       def test(self):
+               return self.locked
+       #
+       # Atomic test-and-set -- grab the lock if it is not set,
+       # return true if it succeeded
+       #
+       def testandset(self):
+               if not self.locked:
+                       self.locked = 1
+                       return 1
+               else:
+                       return 0
+       #
+       # Lock a mutex, call the function with supplied argument
+       # when it is acquired.
+       # If the mutex is already locked, place function and argument
+       # in the queue.
+       #
+       def lock(self, (function, argument)):
+               if self.testandset():
+                       function(argument)
+               else:
+                       self.queue.append(function, argument)
+       #
+       # Unlock a mutex.  If the queue is not empty, call the next
+       # function with its argument.
+       #
+       def unlock(self):
+               if self.queue:
+                       function, argument = self.queue[0]
+                       del self.queue[0]
+                       function(argument)
+               else:
+                       self.locked = 0
+       #