     }
 
     /**
-     * Wait until this mutex is available and then take exclusive ownership,
-     * increase the mutex's lock count by one, and proceed.
-     * This is also known as "acquiring" this mutex.
-     *
-     * If a thread already owns a mutex when this call is made to lock it,
-     * then its internal lock count is increased and no other action occurs.
-     *
+     * Pauses execution of the current worker until this mutex is available and 
+     * then takes ownership of the mutex. If another worker currently owns the 
+     * mutex, the calling worker's execution thread pauses at the 
+     * <code>lock()</code> call and the worker is added to the queue of ownership 
+     * requests. Once it is this worker's turn to own the mutex, the worker's 
+     * execution continues with the line of code following the 
+     * <code>lock()</code> call.
+     *
+     * <p>Once the current worker has ownership of the mutex, it can safely 
+     * operate on the shared resource. When those operations are complete, call 
+     * the <code>unlock()</code> method to release the mutex. At that point the 
+     * current worker should no longer access the shared resource.</p>
+     *
+     * <p>Internally, a mutex keeps a count of the number of lock requests it 
+     * has received. The mutex must receive the same number of unlock requests 
+     * before it is completely released. If code in the worker that owns the 
+     * mutex locks it again (by calling the <code>lock()</code> method) the 
+     * internal lock count increases by one. You must call the 
+     * <code>unlock()</code> method as many times as the number of lock requests 
+     * to release ownership of the mutex.</p>
+     * 
      * @langversion 3.0
      * @playerversion Flash 11.4	
      * @playerversion AIR 3.4

    }

    /**
     * Wakes up all threads/workers waiting on this condition, and releases its mutex.
     * If any threads have been waiting, then one of them acquires the mutex and then 
     * starts executing.
     * All of the above happens atomically.
     *
     * The awoken threads acquire the mutex and proceed one by one, in wait order.
     * Each thread continues to wait until its predecessor releases the mutex
     * (by calling Mutex.unlock or Condition.wait().
     *
     * The current thread/worker must "own" the condition's mutex when making this call.
     * Otherwise an exception is thrown and the mutex and the condition remain unaffected.
     * @throws IllegalOperationError if the condition's mutex is not owned by the current thread.
     *
     * @langversion 3.0
     * @playerversion Flash 11.4	

    }

    /**
     * The mutex associated with this condition.
     *
     * @langversion 3.0
     * @playerversion Flash 11.4	
