 }
     
 /**
- * A Condition (aka condition variable) is a synchronization primitive that facilitates
- * making threads of execution wait until a particular condition occurs.
- *
- * A condition is always associated with a mutex.
- * It can only be manipulated in conjunction with that mutex.
- * This ensures atomic state transitions for all involved threads of execution.
- *
+ * A Condition object is a tool for sharing a resource between workers with the 
+ * additional capability of pausing execution until a particular condition is 
+ * satisfied. A Condition object is used in conjunction with a Mutex object, and 
+ * adds additional functionality to the mutex's behavior. By working in 
+ * combination with a mutex, the runtime ensures that each transition of 
+ * ownership between workers is atomic.
+ * 
+ * <p>The following is one possible workflow for using a Condition object:</p>
+ * <ol>
+ *   <li>Before using a Condition object, the first worker must take ownership 
+ *       of the condition's associated mutex by calling the Mutex object's 
+ *       <code>lock()</code> or <code>tryLock()</code> methods.</li>
+ *   <li>The worker's code operates on the shared resource until some condition 
+ *       becomes false, preventing the worker from doing more work with the 
+ *       shared resource. For example, if the shared resource is a set of data 
+ *       to process, when there is no more data to process the worker can't 
+ *       do any more work.</li>
+ *   <li>At that point, call the Condition object's <code>wait()</code> method 
+ *       to pause the worker's execution and release ownership of the mutex.</li>
+ *   <li>At some point, a second worker takes ownership of the mutex. Because 
+ *       the mutex is available, it is safe for the second worker's code to 
+ *       operate on the shared resource. The second worker does whatever is 
+ *       necessary to satisfy the condition so that the first worker can do its 
+ *       work again. For example, if the first worker has no data to process, 
+ *       the second worker could pass more data to process into the shared resource.</li>
+ *   <li>At that point, the condition related to the first worker's work is now 
+ *       true, so the first worker needs to be notified that the condition is 
+ *       fulfilled. To notify the first worker, the second worker's code calls 
+ *       the Condition object's <code>notify()</code> method or its 
+ *       <code>notifyAll()</code> method.</li>
+ *   <li>In addition to calling <code>notify()</code>, the second worker needs 
+ *       to release ownership of the mutex. It does this either by calling the 
+ *       Mutex object's <code>unlock()</code> method or the Condition object's 
+ *       <code>wait()</code> method. Since the first worker called the 
+ *       <code>wait()</code> method, ownership of the mutex returns to the 
+ *       first worker. Code execution in the first worker then continues again 
+ *       with the next line of code following the <code>wait()</code> call.</li>
+ * </ol>
+ * 
+ * <p>The Condition class is one of the special object types that are shared 
+ * between workers rather than copied between them. When you pass a condition 
+ * from one worker to another worker either by calling the Worker object's 
+ * <code>setSharedProperty()</code> method or by using a MessageChannel object, 
+ * both workers have a reference to the same Condition object in the runtime's 
+ * memory.</p>
+ *
+ * @see flash.concurrent.Mutex Mutex class
+ * @see flash.system.Worker Worker class
+ * 
  * @langversion 3.0
  * @playerversion Flash 11.4	
  * @playerversion AIR 3.4

final public class Mutex
{
    /**
     * The constructor for mutexes.
     *
     * The initial internal lock count of every new mutex is zero.
     *
     * @langversion 3.0
     * @playerversion Flash 11.4	

    }

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