Changes between Initial Version and Version 1 of Lock

Timestamp:

09/29/09 11:18:18 (15 years ago)

Author:

hopscc

Comment:

--

Lock

@@ +1 @@
+= lock = 
+
+Specify a code block to execute after obtaining a lock on the object of an expression.
+
+The code block constitutes a critical section that only one thread may execute at a time.
+
+This construct ensures that one thread does not enter a critical section of 
+code while another thread is in the critical section gated by the same
+locked object. [[BR]]
+If another thread attempts to enter a locked block, it will wait, blocking 
+until the lock on the object is released.
+
+== Grammar ==
+
+{{{
+lock <expression> 
+    <block>
+}}}
+
+
+== Platform ==
+
+On .Net this acts the same as the [http://msdn.microsoft.com/en-us/library/c5kehkcz%28VS.80%29.aspx C# lock statement]
+
+
+== Examples ==
+{{{
+# Critical section is to generate output through a single shared writer fm multiple threads
+class Tester
+    var _statusWriter as Writer?
+...
+    cue init
+    ...
+        _statusWriter = MyWriter()
+        # gen and setup multiple threads with .runInThread as the thread code to run
+    ...
+    
+    def runInThread
+        while true
+            ...
+            lock _statusWriter
+                _statusWriter.writeLine(statusLine)
+            
+}}}
+
+{{{
+# This is the example from the C# lock doc page converted to cobra
+use System.Threading
+
+class Account
+        var _thisLock  = Object()  # is private
+        var balance as int
+        var r = Random()
+
+        cue init(initial as int) is public
+                base.init
+                .balance = initial
+
+        def withdraw(amount as int) as int
+                # This condition will never be true unless the lock statement
+                # is commented out:
+                if .balance < 0
+                        throw Exception("Negative Balance")
+
+                # Comment out the next line to see the effect of leaving out 
+                # the lock keyword:
+                lock _thisLock
+                        if .balance >= amount
+                                print "Balance before Withdrawal :  ", .balance
+                                print "Amount to Withdraw        : -" , amount
+                                .balance = .balance - amount
+                                print "Balance after Withdrawal  :  ", .balance
+                                return amount
+                        else
+                                return 0 # transaction rejected
+
+        def doTransactions is public
+                for i in 0 : 100
+                        .withdraw(.r.next(1, 100))
+
+class Test
+        def main is shared
+                threads = Thread[](10)
+                acc = Account(1000)
+                for i in 0 : 10
+                        t = Thread(ThreadStart(ref acc.doTransactions))
+                        threads[i] = t
+        for i in 0 : 10
+            threads[i].start
+}}}
+
+== Notes ==