Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision bf26fa5c79fea4033feae68da3ea77835a95f61b)
+++ src/libcfa/concurrency/invoke.h	(revision 14f6bb395794c1f66c011077161a28e327f18dd6)
@@ -60,10 +60,10 @@
 
       struct coStack_t {
-            unsigned int size;		// size of stack
-            void *storage;			// pointer to stack
-            void *limit;			// stack grows towards stack limit
-            void *base;				// base of stack
-            void *context;			// address of cfa_context_t
-            void *top;				// address of top of storage
+            unsigned int size;		      // size of stack
+            void *storage;			      // pointer to stack
+            void *limit;			      // stack grows towards stack limit
+            void *base;				      // base of stack
+            void *context;			      // address of cfa_context_t
+            void *top;				      // address of top of storage
             bool userStack;	
       };
@@ -73,15 +73,15 @@
       struct coroutine {
             struct coStack_t stack;
-            const char *name;			// textual name for coroutine/task, initialized by uC++ generated code
-            int errno_;				// copy of global UNIX variable errno
-            enum coroutine_state state;	// current execution status for coroutine
-            struct coroutine *starter;	// first coroutine to resume this one
-            struct coroutine *last;		// last coroutine to resume this one
+            const char *name;			      // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;				      // copy of global UNIX variable errno
+            enum coroutine_state state;	      // current execution status for coroutine
+            struct coroutine *starter;	      // first coroutine to resume this one
+            struct coroutine *last;		      // last coroutine to resume this one
       };
 
       struct thread {
-            struct coroutine c;           // coroutine body used to store context
-            struct signal_once terminated;// indicate if execuation state is not halted
-            struct thread * next;         // instrusive link field for threads
+            struct coroutine c;                 // coroutine body used to store context
+            struct signal_once terminated;      // indicate if execuation state is not halted
+            struct thread * next;               // instrusive link field for threads
       };
 
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision bf26fa5c79fea4033feae68da3ea77835a95f61b)
+++ src/libcfa/concurrency/monitor	(revision 14f6bb395794c1f66c011077161a28e327f18dd6)
@@ -21,23 +21,29 @@
 #include "invoke.h"
 
-struct monitor {
+struct __monitor_t {
 	spinlock lock;
-	thread * holder;
+	thread * owner;
 	simple_thread_list entry_queue;
+	unsigned int recursion;
 };
 
-void enter(monitor *);
-void leave(monitor *);
+static inline void ?{}(__monitor_t * this) {
+	this->owner = 0;
+	this->recursion = 0;
+}
 
-struct monitor_guard {
-	monitor * m;
+void enter(__monitor_t *);
+void leave(__monitor_t *);
+
+struct monitor_guard_t {
+	__monitor_t * m;
 };
 
-static inline void ?{}( monitor_guard * this, monitor * m ) {
+static inline void ?{}( monitor_guard_t * this, __monitor_t * m ) {
 	this->m = m;
 	enter( this->m );
 }
 
-static inline void ^?{}( monitor_guard * this ) {
+static inline void ^?{}( monitor_guard_t * this ) {
 	leave( this->m );
 }
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision bf26fa5c79fea4033feae68da3ea77835a95f61b)
+++ src/libcfa/concurrency/monitor.c	(revision 14f6bb395794c1f66c011077161a28e327f18dd6)
@@ -6,5 +6,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor.c --
+// __monitor_t.c --
 //
 // Author           : Thierry Delisle
@@ -19,15 +19,25 @@
 #include "kernel_private.h"
 
-void enter(monitor * this) {
+void enter(__monitor_t * this) {
 	lock( &this->lock );
 	thread * thrd = this_thread();
 
-	if( this->holder ) {
+	if( !this->owner ) {
+		//No one has the monitor, just take it
+		this->owner = thrd;
+		this->recursion = 1;
+	}
+	else if( this->owner == thrd) {
+		//We already have the monitor, just not how many times we took it
+		assert( this->recursion > 0 );
+		this->recursion += 1;
+	}
+	else {
+		//Some one else has the monitor, wait in line for it
 		append( &this->entry_queue, thrd );
 		ScheduleInternal( &this->lock );
-		return;
-	}
-	else {
-		this->holder = thrd;
+
+		//ScheduleInternal will unlock spinlock, no need to unlock ourselves
+		return; 
 	}
 
@@ -35,14 +45,28 @@
 }
 
-void leave(monitor * this) {
+void leave(__monitor_t * this) {
 	lock( &this->lock );
 
 	thread * thrd = this_thread();
-	assert( thrd == this->holder );
+	assert( thrd == this->owner );
 
-	this->holder = pop_head( &this->entry_queue );
+	//Leaving a recursion level, decrement the counter
+	this->recursion -= 1;
+
+	//If we left the last level of recursion it means we are changing who owns the monitor
+	thread * 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;
+	}	
 
 	unlock( &this->lock );
 
-	if( this->holder ) ScheduleThread( this->holder );
+	//If we have a new owner, we need to wake-up the thread
+	if( new_owner ) {
+		ScheduleThread( new_owner );
+	}
 }
