Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 6c6455fa3aff35b9e4792ff0598a10b9ba27d3ea)
+++ src/libcfa/concurrency/monitor	(revision 2c9ebabd500b086aeb45d01caed3a928fad5b3c2)
@@ -87,3 +87,4 @@
 void wait( condition * this );
 void signal( condition * this );
+void signal_block( condition * this );
 #endif //MONITOR_H
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 6c6455fa3aff35b9e4792ff0598a10b9ba27d3ea)
+++ src/libcfa/concurrency/monitor.c	(revision 2c9ebabd500b086aeb45d01caed3a928fad5b3c2)
@@ -62,4 +62,5 @@
 			//Some one else has the monitor, wait in line for it
 			append( &this->entry_queue, thrd );
+			LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd);
 			ScheduleInternal( &this->lock );
 
@@ -97,4 +98,6 @@
 		unlock( &this->lock );
 
+		LIB_DEBUG_PRINT_SAFE("Next owner is %p\n", new_owner);
+
 		//We need to wake-up the thread
 		ScheduleThread( new_owner );
@@ -149,4 +152,5 @@
 	assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
 	assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+	assertf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
 
 	unsigned short count = this->monitor_count;
@@ -184,6 +188,4 @@
 	}
 
-	debug_break();
-
 	for( int i = 0; i < count; i++) {
 		thread_desc * new_owner = next_thread( this->monitors[i] );
@@ -191,6 +193,4 @@
 	}
 
-	debug_break();
-
 	LIB_DEBUG_PRINT_SAFE("Will unblock: ");
 	for(int i = 0; i < thread_count; i++) {
@@ -202,5 +202,5 @@
 	ScheduleInternal( locks, count, threads, thread_count );
 
-
+	debug_break();
 	//WE WOKE UP
 
@@ -224,4 +224,5 @@
 	unsigned short count = this->monitor_count;
 	
+	//Some more checking in debug
 	LIB_DEBUG_DO(
 		thread_desc * this_thrd = this_thread();
@@ -237,8 +238,12 @@
 	);
 
+	//Lock all the monitors
 	lock_all( this->monitors, NULL, count );
 	LIB_DEBUG_PRINT_SAFE("Signalling");
 
+	//Pop the head of the waiting queue
 	__condition_node_t * node = pop_head( &this->blocked );
+
+	//Add the thread to the proper AS stack
 	for(int i = 0; i < count; i++) {
 		__condition_criterion_t * crit = &node->criteria[i];
@@ -250,5 +255,64 @@
 	LIB_DEBUG_PRINT_SAFE("\n");
 
+	//Release
 	unlock_all( this->monitors, count );
+}
+
+void signal_block( condition * this ) {
+	if( !this->blocked.head ) {
+		LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
+		return;
+	}
+
+	//Check that everything is as expected
+	assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+	assertf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+
+	unsigned short count = this->monitor_count;
+	unsigned int recursions[ count ];		//Save the current recursion levels to restore them later
+	spinlock *   locks     [ count ];		//We need to pass-in an array of locks to ScheduleInternal
+
+	lock_all( this->monitors, locks, count );
+
+	//create creteria
+	__condition_node_t waiter;
+	waiter.waiting_thread = this_thread();
+	waiter.count = count;
+	waiter.next = NULL;
+
+	__condition_criterion_t criteria[count];
+	for(int i = 0; i < count; i++) {
+		LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+		criteria[i].ready  = false;
+		criteria[i].owner  = &waiter;
+		criteria[i].next   = NULL;
+		criteria[i].target = this->monitors[i];
+		push( &criteria[i].target->signal_stack, &criteria[i] );
+	}
+
+	waiter.criteria = criteria;
+
+	//save contexts
+	save_recursion( this->monitors, recursions, count );
+
+	//Find the thread to run
+	thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+	for(int i = 0; i < count; i++) {
+		set_owner( this->monitors[i], signallee );
+	}
+
+	LIB_DEBUG_PRINT_SAFE( "Waiting on signal block\n" );
+	debug_break();
+
+	//Everything is ready to go to sleep
+	ScheduleInternal( locks, count, &signallee, 1 );
+
+	debug_break();
+	LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
+
+	//We are back, restore the owners and recursions
+	lock_all( locks, count );
+	restore_recursion( this->monitors, recursions, count );
+	unlock_all( locks, count );
 }
 
@@ -335,4 +399,5 @@
 
 	for(	int i = 0; i < count; i++ ) {
+
 		LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
 		if( &criteria[i] == target ) {
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 6c6455fa3aff35b9e4792ff0598a10b9ba27d3ea)
+++ src/libcfa/concurrency/thread	(revision 2c9ebabd500b086aeb45d01caed3a928fad5b3c2)
@@ -82,4 +82,5 @@
 
 void yield();
+void yield( unsigned times );
 
 #endif //THREADS_H
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 6c6455fa3aff35b9e4792ff0598a10b9ba27d3ea)
+++ src/libcfa/concurrency/thread.c	(revision 2c9ebabd500b086aeb45d01caed3a928fad5b3c2)
@@ -87,4 +87,10 @@
 }
 
+void yield( unsigned times ) {
+	for( unsigned i = 0; i < times; i++ ) {
+		yield();
+	}
+}
+
 void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
 	// set state of current coroutine to inactive