Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 626da64418241876f30b5a7cd87ebb6afaeef2c7)
+++ src/libcfa/concurrency/invoke.h	(revision 690f13c38d3a5ec73971561f04e500f6ceba7c9c)
@@ -38,4 +38,8 @@
       };
 
+      struct simple_thread_stack {
+            struct thread_desc * top;
+      };
+
       #ifdef __CFORALL__
       extern "Cforall" {
@@ -43,4 +47,8 @@
             void append( struct simple_thread_list *, struct thread_desc * );
             struct thread_desc * pop_head( struct simple_thread_list * );
+
+            void ?{}( struct simple_thread_stack * );
+            void push( struct simple_thread_stack *, struct thread_desc * );            
+            struct thread_desc * pop( struct simple_thread_stack * );
 
             void ?{}(spinlock * this);
@@ -74,4 +82,6 @@
             struct thread_desc * owner;
             struct simple_thread_list entry_queue;
+            struct simple_thread_stack signal_stack;
+            struct monitor_desc * stack_owner;
             unsigned int recursion;
       };
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 626da64418241876f30b5a7cd87ebb6afaeef2c7)
+++ src/libcfa/concurrency/kernel.c	(revision 690f13c38d3a5ec73971561f04e500f6ceba7c9c)
@@ -294,4 +294,6 @@
 // Scheduler routines
 void ScheduleThread( thread_desc * thrd ) {
+	if( !thrd ) return;
+
 	assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
 	
@@ -468,4 +470,23 @@
 	return head;
 }
+
+void ?{}( simple_thread_stack * this ) {
+	this->top = NULL;
+}
+
+void push( simple_thread_stack * this, thread_desc * t ) {
+	assert(t->next != NULL);
+	t->next = this->top;
+	this->top = t;
+}
+
+thread_desc * pop( simple_thread_stack * this ) {
+	thread_desc * top = this->top;
+	if( top ) {
+		this->top = top->next;
+		top->next = NULL;
+	}	
+	return top;
+}
 // Local Variables: //
 // mode: c //
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 626da64418241876f30b5a7cd87ebb6afaeef2c7)
+++ src/libcfa/concurrency/monitor	(revision 690f13c38d3a5ec73971561f04e500f6ceba7c9c)
@@ -18,4 +18,6 @@
 #define MONITOR_H
 
+#include <stddef.h>
+
 #include "assert"
 #include "invoke.h"
@@ -23,5 +25,6 @@
 
 static inline void ?{}(monitor_desc * this) {
-	this->owner = 0;
+	this->owner = NULL;
+      this->stack_owner = NULL;
 	this->recursion = 0;
 }
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 626da64418241876f30b5a7cd87ebb6afaeef2c7)
+++ src/libcfa/concurrency/monitor.c	(revision 690f13c38d3a5ec73971561f04e500f6ceba7c9c)
@@ -18,4 +18,12 @@
 
 #include "kernel_private.h"
+
+void set_owner( monitor_desc * this, thread_desc * owner ) {
+	//Pass the monitor appropriately
+	this->owner = owner;
+
+	//We are passing the monitor to someone else, which means recursion level is not 0
+	this->recursion = owner ? 1 : 0;
+}
 
 extern "C" {
@@ -46,4 +54,19 @@
 	}
 
+	// leave pseudo code :
+	// 	decrement level
+	// 	leve == 0 ?
+	// 		no : done
+	// 		yes :
+	// 			signal stack empty ?
+	//				has leader :
+	//					bulk acquiring means we don't own the signal stack
+	//					ignore it but don't release the monitor
+	// 				yes :
+	// 					next in entry queue is new owner
+	// 				no :
+	// 					top of the signal stack is the owner
+	//					context switch to him right away
+	//
 	void __leave_monitor_desc(monitor_desc * this) {
 		lock( &this->lock );
@@ -55,20 +78,42 @@
 		this->recursion -= 1;
 
-		//If we left the last level of recursion it means we are changing who owns the monitor
+		//If we haven't left the last level of recursion
+		//it means we don't need to do anything
+		if( this->recursion != 0) {
+			unlock( &this->lock );
+			return;
+		}
+			
+		//If we don't own the signal stack then just leave it to the owner
+		if( this->stack_owner ) {
+			assert( this->owner == this->stack_owner );
+			unlock( &this->lock );
+			return;
+		}
+
+		//We are the stack owner and have left the last recursion level.
+		//We are in charge of passing the monitor
 		thread_desc * new_owner = 0;
-		if( this->recursion == 0) {
-			//Get the next thread in the list
-			new_owner = this->owner = pop_head( &this->entry_queue );
 
-			//We are passing the monitor to someone else, which means recursion level is not 0
-			this->recursion = new_owner ? 1 : 0;
-		}	
+		//Check the signaller stack
+		new_owner = pop( &this->signal_stack );
+		if( new_owner ) {
+			//The signaller stack is not empty,
+			//transfer control immediately
+			set_owner( this, new_owner );
+			ScheduleInternal( &this->lock, new_owner );
+			return;
+		}
+		
+		// No signaller thread
+		// Get the next thread in the entry_queue
+		new_owner = pop_head( &this->entry_queue );
+		set_owner( this, new_owner );
 
+		//We can now let other threads in safely
 		unlock( &this->lock );
 
-		//If we have a new owner, we need to wake-up the thread
-		if( new_owner ) {
-			ScheduleThread( new_owner );
-		}
+		//We need to wake-up the thread
+		ScheduleThread( new_owner );
 	}
 }