diff --git a/docs/src/docbkx/reference/deployment.xml b/docs/src/docbkx/reference/deployment.xml
index 16ba872..371d89c 100644
--- a/docs/src/docbkx/reference/deployment.xml
+++ b/docs/src/docbkx/reference/deployment.xml
@@ -363,9 +363,7 @@
                 <footnote>Part of <literal>org.springframework.core.task</literal> package</footnote></entry>
                 <entry>Creates and runs the Spring application contexts associated with each bundle. The task executor is responsible for managing its own pool
                 of threads used by the application contexts</entry>
-                <entry><classname>SimpleAsyncTaskExecutor</classname> is used by default which means a new thread will be created for each application contexts. While this
-                is suitable for testing and development, we strongly recommend to use a <ulink url="http://en.wikipedia.org/wiki/Thread_pool_pattern">thread pool</ulink> 
-                in a production environment</entry>
+                <entry><classname>ThreadPoolTaskExecutor</classname> with a maximum number of threads equal to the number of available processors is used by default.</entry>
               </row>
 
               <row>
@@ -374,9 +372,9 @@
                 <footnote>Part of <literal>org.springframework.core.task</literal> package</footnote></entry>
                 <entry>Destroys managed Spring application contexts associated with each bundle. The task executor is responsible for managing its own pool
                 of threads used by the application contexts</entry>
-                <entry><classname>SimpleAsyncTaskExecutor</classname> is used by default which means all application context will be destroyed in a serialized manner (which is
-                desired). Since the shutdown order normally matters, it is recommended to keep the default implementation or, for managed environments, to use a thread-pool
-                that executes only one task at a time (so that contexts are stopped in the given order).</entry>
+                <entry><classname>ThreadPoolTaskExecutor</classname> with a single thread is used by default which means all application context will be destroyed in a serialized manner (which is
+                  desired). Since the shutdown order normally matters, it is recommended to keep the default implementation or, for managed environments, to use a thread-pool
+                  that executes only one task at a time (so that contexts are stopped in the given order).</entry>
               </row>
               
               <row>
diff --git a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfiguration.java b/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfiguration.java
index 043ada0..8370c62 100644
--- a/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfiguration.java
+++ b/extender/src/main/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfiguration.java
@@ -33,8 +33,8 @@
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.context.event.SimpleApplicationEventMulticaster;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.task.TaskExecutor;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
@@ -259,7 +259,7 @@
 
 				if (isTaskExecutorManagedInternally) {
 					log.warn("Forcing the (internally created) taskExecutor to stop...");
-					ThreadGroup th = ((SimpleAsyncTaskExecutor) taskExecutor).getThreadGroup();
+					ThreadGroup th = ((ThreadPoolTaskExecutor) taskExecutor).getThreadGroup();
 					if (!th.isDestroyed()) {
 						// ask the threads nicely to stop
 						th.interrupt();
@@ -360,9 +360,11 @@
 				new ThreadGroup("eclipse-gemini-blueprint-extender[" + ObjectUtils.getIdentityHexString(this) + "]-threads");
 		threadGroup.setDaemon(false);
 
-		SimpleAsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
+		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
+		taskExecutor.setMaxPoolSize(Runtime.getRuntime().availableProcessors());
 		taskExecutor.setThreadGroup(threadGroup);
 		taskExecutor.setThreadNamePrefix("EclipseGeminiBlueprintExtenderThread-");
+		taskExecutor.initialize();
 
 		isTaskExecutorManagedInternally = true;
 
@@ -370,10 +372,14 @@
 	}
 
 	private TaskExecutor createDefaultShutdownTaskExecutor() {
-		SimpleAsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("Gemini Blueprint context shutdown thread ");
+		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
+		taskExecutor.setThreadNamePrefix("Gemini Blueprint context shutdown thread ");
 		taskExecutor.setDaemon(true);
-		taskExecutor.setConcurrencyLimit(1);
+		taskExecutor.setMaxPoolSize(1);
+		taskExecutor.initialize();
+
 		isShutdownTaskExecutorManagedInternally = true;
+
 		return taskExecutor;
 	}
 
diff --git a/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationCustomSettingsTest.java b/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationCustomSettingsTest.java
index ece5843..3456892 100644
--- a/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationCustomSettingsTest.java
+++ b/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationCustomSettingsTest.java
@@ -22,8 +22,8 @@
 import org.eclipse.gemini.blueprint.mock.MockBundleContext;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.task.TaskExecutor;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 import java.net.URL;
 import java.util.Enumeration;
@@ -58,13 +58,13 @@
 	}
 
 	public void testTaskExecutor() throws Exception {
-		assertTrue(config.getTaskExecutor() instanceof SimpleAsyncTaskExecutor);
-		assertEquals("conf-extender-thread", ((SimpleAsyncTaskExecutor) config.getTaskExecutor()).getThreadNamePrefix());
+		assertTrue(config.getTaskExecutor() instanceof ThreadPoolTaskExecutor);
+		assertEquals("conf-extender-thread", ((ThreadPoolTaskExecutor) config.getTaskExecutor()).getThreadNamePrefix());
 	}
 
 	public void testShutdownTaskExecutor() throws Exception {
 		TaskExecutor executor = config.getShutdownTaskExecutor();
-		assertTrue(executor instanceof SimpleAsyncTaskExecutor);
+		assertTrue(executor instanceof ThreadPoolTaskExecutor);
 	}
 
 	public void testEventMulticaster() throws Exception {
diff --git a/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java b/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java
index 1d60e38..520e36a 100644
--- a/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java
+++ b/extender/src/test/java/org/eclipse/gemini/blueprint/extender/internal/support/ExtenderConfigurationDefaultSettingsTest.java
@@ -19,8 +19,8 @@
 import org.eclipse.gemini.blueprint.extender.internal.dependencies.startup.MandatoryImporterDependencyFactory;
 import org.eclipse.gemini.blueprint.mock.MockBundleContext;
 import org.osgi.framework.BundleContext;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.task.TaskExecutor;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 import java.util.List;
 
@@ -44,12 +44,12 @@
 	}
 
 	public void testTaskExecutor() throws Exception {
-		assertTrue(config.getTaskExecutor() instanceof SimpleAsyncTaskExecutor);
+		assertTrue(config.getTaskExecutor() instanceof ThreadPoolTaskExecutor);
 	}
 
 	public void testShutdownTaskExecutor() throws Exception {
 		TaskExecutor executor = config.getShutdownTaskExecutor();
-		assertTrue(executor instanceof SimpleAsyncTaskExecutor);
+		assertTrue(executor instanceof ThreadPoolTaskExecutor);
 	}
 
 	public void testEventMulticaster() throws Exception {
diff --git a/extender/src/test/resources/org/eclipse/gemini/blueprint/extender/internal/support/extender-custom-config.xml b/extender/src/test/resources/org/eclipse/gemini/blueprint/extender/internal/support/extender-custom-config.xml
index 1d4ad3c..f3d33ad 100644
--- a/extender/src/test/resources/org/eclipse/gemini/blueprint/extender/internal/support/extender-custom-config.xml
+++ b/extender/src/test/resources/org/eclipse/gemini/blueprint/extender/internal/support/extender-custom-config.xml
@@ -1,18 +1,16 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xmlns:osgi="http://www.springframework.org/schema/osgi"
-	xmlns:util="http://www.springframework.org/schema/util"
-	xmlns:p="http://www.springframework.org/schema/p"
-	xsi:schemaLocation="
-		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
-		http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd
+	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	   xmlns:util="http://www.springframework.org/schema/util"
+	   xmlns:p="http://www.springframework.org/schema/p"
+	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+
 		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 
-	<bean id="taskExecutor" class="org.springframework.core.task.SimpleAsyncTaskExecutor" p:threadGroupName="configured-extender" 
-			p:threadNamePrefix="conf-extender-thread" />
+	<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" p:threadGroupName="configured-extender"
+		  p:threadNamePrefix="conf-extender-thread" />
 
-	<bean id="shutdownTaskExecutor" class="org.springframework.core.task.SimpleAsyncTaskExecutor"/>
+	<bean id="shutdownTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"/>
 	
 	<bean id="applicationEventMulticaster" class="org.eclipse.gemini.blueprint.extender.internal.support.DummyApplicationEventMulticaster"/>
 	
diff --git a/integration-tests/bundles/extender.fragment.bundle/src/main/resources/META-INF/spring/extender/extra-config.xml b/integration-tests/bundles/extender.fragment.bundle/src/main/resources/META-INF/spring/extender/extra-config.xml
index 2e30c21..0ef66ee 100644
--- a/integration-tests/bundles/extender.fragment.bundle/src/main/resources/META-INF/spring/extender/extra-config.xml
+++ b/integration-tests/bundles/extender.fragment.bundle/src/main/resources/META-INF/spring/extender/extra-config.xml
@@ -12,10 +12,10 @@
 	<osgi:reference id="packageAdmin"
 		interface="org.osgi.service.packageadmin.PackageAdmin" cardinality="0..1"/>
 
-	<bean id="taskExecutor" class="org.springframework.core.task.SimpleAsyncTaskExecutor" p:threadGroupName="configured-extender" 
-			p:threadNamePrefix="conf-extender-thread" />
+	<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" p:threadGroupName="configured-extender"
+		  p:threadNamePrefix="conf-extender-thread" />
 
-	<bean id="shutdownTaskExecutor" class="org.springframework.core.task.SimpleAsyncTaskExecutor"/>
+	<bean id="shutdownTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"/>
 	
 	<util:properties id="extenderProperties">
 		<prop key="smth">bla</prop>
diff --git a/integration-tests/tests/src/test/java/org/eclipse/gemini/blueprint/iandt/extender/configuration/ExtenderConfigurationTest.java b/integration-tests/tests/src/test/java/org/eclipse/gemini/blueprint/iandt/extender/configuration/ExtenderConfigurationTest.java
index 96bb448..221d9b1 100644
--- a/integration-tests/tests/src/test/java/org/eclipse/gemini/blueprint/iandt/extender/configuration/ExtenderConfigurationTest.java
+++ b/integration-tests/tests/src/test/java/org/eclipse/gemini/blueprint/iandt/extender/configuration/ExtenderConfigurationTest.java
@@ -20,8 +20,8 @@
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.packageadmin.PackageAdmin;
 import org.springframework.context.ApplicationContext;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.task.TaskExecutor;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 import java.util.List;
 import java.util.Properties;
@@ -67,7 +67,7 @@
 	public void testShutdownTaskExecutor() throws Exception {
 		assertTrue(context.containsBean("shutdownTaskExecutor"));
 		Object bean = context.getBean("shutdownTaskExecutor");
-		assertTrue("unexpected type", bean instanceof SimpleAsyncTaskExecutor);
+		assertTrue("unexpected type", bean instanceof ThreadPoolTaskExecutor);
 	}
 
 	public void testTaskExecutor() throws Exception {
