Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision dff1fd1af08a6ae85e2ef95b1104d6058c4419d4)
+++ libcfa/src/concurrency/locks.cfa	(revision 26a249c936f6af6667e7f64d46e614df00675492)
@@ -1,10 +1,7 @@
 #include "locks.hfa"
 #include "kernel_private.hfa"
-#include <stdlib.h>
-#include <stdio.h>
 
 #include <kernel.hfa>
 #include <stdlib.hfa>
-#include <thread.hfa>
 
 ///////////////////////////////////////////////////////////////////
@@ -61,15 +58,15 @@
 void lock( blocking_lock & this ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
-	if ( owner == active_thread() && !multi_acquisition) {
+	if ( owner == active_thread() && !multi_acquisition) { // single acquisition lock is held by current thread
 		abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
-	} else if ( owner != 0p && owner != active_thread() ) {
+	} else if ( owner != 0p && owner != active_thread() ) {	// lock is held by some other thread
 		addTail( blocked_threads, *active_thread() );
 		wait_count++;
 		unlock( lock );
 		park( );
-	} else if ( owner == active_thread() && multi_acquisition ) {
+	} else if ( owner == active_thread() && multi_acquisition ) { // multi acquisition lock is held by current thread
 		recursion_count++;
 		unlock( lock );
-	} else {
+	} else { // lock isn't held
 		owner = active_thread();
 		recursion_count = 1;
@@ -81,9 +78,9 @@
 	bool ret = false;
 	lock( lock __cfaabi_dbg_ctx2 );
-	if ( owner == 0p ) {
+	if ( owner == 0p ) { // lock isn't held
 		owner = active_thread();
 		recursion_count = 1;
 		ret = true;
-	} else if ( owner == active_thread() && multi_acquisition ) {
+	} else if ( owner == active_thread() && multi_acquisition ) { // multi acquisition lock is held by current thread
 		recursion_count++;
 		ret = true;
@@ -94,5 +91,5 @@
 
 void unlock_error_check( blocking_lock & this ) with( this ) {
-	if ( owner == 0p ){ // no owner implies lock isn't held
+	if ( owner == 0p ){ // lock isn't held
 		abort( "There was an attempt to release a lock that isn't held" ); 
 	} else if ( strict_owner && owner != active_thread() ) {
@@ -113,5 +110,5 @@
 	unlock_error_check( this );
 	recursion_count--;
-	if ( recursion_count == 0 ) {
+	if ( recursion_count == 0 ) { // if recursion count is zero release lock and set new owner if one is waiting
 		pop_and_set_new_owner( this );
 	}
@@ -131,11 +128,11 @@
 }
 
-void add_( blocking_lock & this, $thread * t ) with( this ) {
+void on_notify( blocking_lock & this, $thread * t ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
-	if ( owner != 0p ) {
+	if ( owner != 0p ) { // lock held
 		addTail( blocked_threads, *t );
 		wait_count++;
 		unlock( lock );
-	} else {
+	} else {	// lock not held
 		owner = t;
 		recursion_count = 1;
@@ -145,5 +142,5 @@
 }
 
-void remove_( blocking_lock & this ) with( this ) {
+void on_wait( blocking_lock & this ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
 	unlock_error_check( this );
@@ -156,10 +153,10 @@
 ///////////////////////////////////////////////////////////////////
 
-// This is temporary until an inheritance bug is fixed
+// These routines are temporary until an inheritance bug is fixed
 
 void lock( single_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( single_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( single_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( single_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( single_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( single_acquisition_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( single_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( single_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -167,6 +164,6 @@
 void lock( owner_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( owner_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( owner_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( owner_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( owner_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( owner_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( owner_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( owner_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -174,6 +171,6 @@
 void lock( multiple_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( multiple_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( multiple_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( multiple_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( multiple_acquisition_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -188,13 +185,16 @@
     	// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
 	    lock( cond->lock __cfaabi_dbg_ctx2 );
-	    if ( listed(i) ) {			// is thread on queue
+
+	    // this check is necessary to avoid a race condition since this timeout handler 
+	    // 	may still be called after a thread has been removed from the queue but 
+	    // 	before the alarm is unregistered
+	    if ( listed(i) ) {							// is thread on queue
 	    	i->signalled = false;
-	    	cond->last_thread = i;		// REMOVE THIS AFTER DEBUG
-			remove( cond->blocked_threads, *i );		 //remove this thread O(1)
+			remove( cond->blocked_threads, *i );	// remove this thread O(1)
 			cond->count--;
-			if( !i->lock ) {
-				unpark( i->t );
+			if( i->lock ) {
+				on_notify(*i->lock, i->t);			// call lock's on_notify if a lock was passed
 	    	} else {
-	    		add_(*i->lock, i->t);			// call lock's add_
+	    		unpark( i->t );						// otherwise wake thread
 	    	}
 	    }
@@ -202,4 +202,5 @@
 	}
 
+	// this casts the alarm node to our wrapped type since we used type erasure
 	void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
 
@@ -208,5 +209,4 @@
 		this.blocked_threads{};
 		this.count = 0;
-		this.last_thread = 0p; // REMOVE AFTER DEBUG
 	}
 
@@ -224,7 +224,7 @@
 			count--;
 			if (popped.lock) {
-				add_(*popped.lock, popped.t);
+				on_notify(*popped.lock, popped.t); // if lock passed call on_notify
 			} else {
-				unpark(popped.t);
+				unpark(popped.t); // otherwise wake thread
 			}
 		}
@@ -258,10 +258,10 @@
 
 	size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
-		addTail( blocked_threads, *i );
+		addTail( blocked_threads, *i ); // add info_thread to waiting queue
 		count++;
 		size_t recursion_count = 0;
-		if (i->lock) {
+		if (i->lock) { // if lock was passed get recursion count to reset to after waking thread
 			recursion_count = get_recursion_count(*i->lock);
-			remove_( *i->lock );
+			on_wait( *i->lock );
 		}
 		return recursion_count;
@@ -287,6 +287,6 @@
 		unlock( lock );
 		park();
-		unregister_self( &node_wrap.alarm_node );
-		if (info.lock) set_recursion_count(*info.lock, recursion_count);
+		unregister_self( &node_wrap.alarm_node ); // unregisters alarm so it doesn't go off if this happens first
+		if (info.lock) set_recursion_count(*info.lock, recursion_count); // resets recursion count here after waking
 	}
 
