Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/Concurrency/Keywords.cc	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -331,8 +331,10 @@
 			),
 			new ListInit(
-				map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
+				map_range < std::list<Initializer*> > ( args, [this](DeclarationWithType * var ){
+					Type * type = var->get_type()->clone();
+					type->set_mutex( false );
 					return new SingleInit( new UntypedExpr(
 						new NameExpr( "get_monitor" ),
-						{  new VariableExpr( var ) }
+						{  new CastExpr( new VariableExpr( var ), type ) }
 					) );
 				})
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/invoke.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -29,5 +29,5 @@
 
 extern void __suspend_internal(void);
-extern void __thread_signal_termination(struct thread_desc*);
+extern void __leave_monitor_desc( struct monitor_desc * this );
 
 void CtxInvokeCoroutine(
@@ -65,4 +65,5 @@
       struct thread_desc* thrd = get_thread( this );
       struct coroutine_desc* cor = &thrd->cor;
+      struct monitor_desc* mon = &thrd->mon;
       cor->state = Active;
 
@@ -70,5 +71,5 @@
       main( this );
 
-      __thread_signal_termination(thrd);
+      __leave_monitor_desc( mon );
 
       //Final suspend, should never return
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/invoke.h	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -38,10 +38,4 @@
       };
 
-      struct signal_once {
-            volatile bool condition;
-            struct spinlock lock;
-            struct simple_thread_list blocked;
-      };
-
       #ifdef __CFORALL__
       extern "Cforall" {
@@ -52,7 +46,4 @@
             void ?{}(spinlock * this);
             void ^?{}(spinlock * this);
-
-            void ?{}(signal_once * this);
-            void ^?{}(signal_once * this);
       }
       #endif
@@ -79,7 +70,14 @@
       };
 
+      struct monitor_desc {
+            struct spinlock lock;
+            struct thread_desc * owner;
+            struct simple_thread_list entry_queue;
+            unsigned int recursion;
+      };
+
       struct thread_desc {
-            struct coroutine_desc cor;            // coroutine body used to store context
-            struct signal_once terminated;      // indicate if execuation state is not halted
+            struct coroutine_desc cor;          // coroutine body used to store context
+            struct monitor_desc mon;            // monitor body used for mutual exclusion
             struct thread_desc * next;          // instrusive link field for threads
       };
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/kernel	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -30,4 +30,13 @@
 void lock( spinlock * );
 void unlock( spinlock * );
+
+struct signal_once {
+	volatile bool condition;
+	struct spinlock lock;
+	struct simple_thread_list blocked;
+};
+
+void ?{}(signal_once * this);
+void ^?{}(signal_once * this);
 
 void wait( signal_once * );
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/monitor	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -21,11 +21,4 @@
 #include "invoke.h"
 #include "stdlib"
-
-struct monitor_desc {
-	spinlock lock;
-	thread_desc * owner;
-	simple_thread_list entry_queue;
-	unsigned int recursion;
-};
 
 static inline void ?{}(monitor_desc * this) {
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/monitor.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -19,54 +19,56 @@
 #include "kernel_private.h"
 
-void enter(monitor_desc * this) {
-	lock( &this->lock );
-	thread_desc * thrd = this_thread();
+extern "C" {
+	void __enter_monitor_desc(monitor_desc * this) {
+		lock( &this->lock );
+		thread_desc * thrd = this_thread();
 
-	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 );
+		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 );
 
-		//ScheduleInternal will unlock spinlock, no need to unlock ourselves
-		return; 
+			//ScheduleInternal will unlock spinlock, no need to unlock ourselves
+			return; 
+		}
+
+		unlock( &this->lock );
 	}
 
-	unlock( &this->lock );
-}
+	void __leave_monitor_desc(monitor_desc * this) {
+		lock( &this->lock );
 
-void leave(monitor_desc * this) {
-	lock( &this->lock );
+		thread_desc * thrd = this_thread();
+		assert( thrd == this->owner );
 
-	thread_desc * thrd = this_thread();
-	assert( thrd == this->owner );
+		//Leaving a recursion level, decrement the counter
+		this->recursion -= 1;
 
-	//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_desc * new_owner = 0;
+		if( this->recursion == 0) {
+			//Get the next thread in the list
+			new_owner = this->owner = pop_head( &this->entry_queue );
 
-	//If we left the last level of recursion it means we are changing who owns 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;
+		}	
 
-		//We are passing the monitor to someone else, which means recursion level is not 0
-		this->recursion = new_owner ? 1 : 0;
-	}	
+		unlock( &this->lock );
 
-	unlock( &this->lock );
-
-	//If we have a new owner, we need to wake-up the thread
-	if( new_owner ) {
-		ScheduleThread( new_owner );
+		//If we have a new owner, we need to wake-up the thread
+		if( new_owner ) {
+			ScheduleThread( new_owner );
+		}
 	}
 }
@@ -74,5 +76,5 @@
 void enter(monitor_desc ** monitors, int count) {
 	for(int i = 0; i < count; i++) {
-		enter( monitors[i] );
+		__enter_monitor_desc( monitors[i] );
 	}
 }
@@ -80,5 +82,5 @@
 void leave(monitor_desc ** monitors, int count) {
 	for(int i = count - 1; i >= 0; i--) {
-		leave( monitors[i] );
+		__leave_monitor_desc( monitors[i] );
 	}
 }
Index: src/libcfa/concurrency/thread
===================================================================
--- src/libcfa/concurrency/thread	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/thread	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -22,4 +22,5 @@
 
 #include "coroutine"
+#include "monitor"
 
 //-----------------------------------------------------------------------------
@@ -28,5 +29,5 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
-      void ^?{}(T* this);
+      void ^?{}(T* mutex this);
       void main(T* this);
       thread_desc* get_thread(T* this);
@@ -40,6 +41,15 @@
 }
 
-static inline coroutine_desc* get_coroutine(thread_desc* this) {
+forall( dtype T | is_thread(T) )
+static inline monitor_desc* get_monitor(T * this) {
+	return &get_thread(this)->mon;
+}
+
+static inline coroutine_desc* get_coroutine(thread_desc * this) {
 	return &this->cor;
+}
+
+static inline monitor_desc* get_monitor(thread_desc * this) {
+	return &this->mon;
 }
 
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/libcfa/concurrency/thread.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -35,7 +35,4 @@
 void start( T* this );
 
-forall( dtype T | is_thread(T) )
-void stop( T* this );
-
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
@@ -44,5 +41,6 @@
 	(&this->cor){};
 	this->cor.name = "Anonymous Coroutine";
-	(&this->terminated){};
+	this->mon.owner = this;
+	this->mon.recursion = 1;
 	this->next = NULL;
 }
@@ -66,5 +64,4 @@
 forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this ) {
-	stop(&this->handle);
 	^(&this->handle){};
 }
@@ -86,9 +83,4 @@
 
 	ScheduleThread(thrd_h);
-}
-
-forall( dtype T | is_thread(T) )
-void stop( T* this ) {
-	wait( & get_thread(this)->terminated );	
 }
 
@@ -116,14 +108,4 @@
 }
 
-// C Helper to signal the termination of a thread_desc
-// Used in invoke.c
-extern "C" {
-	void __thread_signal_termination( thread_desc * this ) {
-		this->cor.state = Halted;
-		LIB_DEBUG_PRINTF("Thread end : %p\n", this);
-		signal( &this->terminated );	
-	}
-}
-
 // Local Variables: //
 // mode: c //
Index: src/tests/monitor.c
===================================================================
--- src/tests/monitor.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/tests/monitor.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -36,7 +36,8 @@
 
 void ?{}( MyThread * this ) {}
+void ^?{}( MyThread * mutex this ) {}
 
 void main( MyThread* this ) {
-	for(int i = 0; i < 1000000; i++) {
+	for(int i = 0; i < 1_000_000; i++) {
 		increment( &global );
 	}
Index: src/tests/multi-monitor.c
===================================================================
--- src/tests/multi-monitor.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/tests/multi-monitor.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -31,4 +31,6 @@
 }
 
+void ^?{}( MyThread * mutex this ) {}
+
 void main( MyThread* this ) {
 	for(int i = 0; i < 1000000; i++) {
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision 597db97fd3bb3ae39d9d8b56882a8705b6f0880c)
+++ src/tests/thread.c	(revision 349b2cb8a8937888f8bb7df7b531e452e5777a94)
@@ -12,4 +12,7 @@
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
+
+void ^?{}( First  * mutex this ) {}
+void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {