Printemps SimpleAsyncTaskExecutor et ThreadPoolTaskExecutor avec @Async annotation
J'ai le texte suivant configutation:
<?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:context="http://www.springframework.org/schema/context"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">
<context:component-scan base-package="com.abc" />
<task:annotation-driven executor="executor"/>
<task:executor id="executor" pool-size="2"/>
</beans>
Puis la classe suivante
public class SomeClassImpl implements SomeClass {
@Async
@Override //overridden from the interface
public void doSomething(){
System.out.println("doing something async");
}
}
Un test:
@ContextConfiguration("classpath:test-config.xml") //with the xml config above
@RunWith(value = SpringJUnit4ClassRunner.class)
public class SomeClassTest {
@Autowired
private SomeClass someClass;
@Test
public void testSomething() throws Exception {
System.out.println("Calling doSomething");
someClass.doSomething();
Thread.sleep(5000);
}
}
Quand j'ai couru le test, tout a fonctionné comme prévu. Mais ensuite, j'ai fixé le débogueur à l'étape par le biais de ce qui se passe réellement lorsque someClass.doSomething() est appelée et j'ai remarqué ce qui suit:
Pourquoi est-ce que 4 threads sont créés par un SimpleAsyncTaskExecutor? Je sais que si je supprime le liquidateur des biens de la tâche:annotation-driven élément xml, le AsyncExecutionInterceptor utilisera le SimpleAsyncTaskExecutor. Mais depuis que j'ai déclaré un exécuteur de tâches et de le référencer à partir de l'annotation-driven élément, pourquoi est un SimpleAsyncTaskExecutor en cours de création?
<task:annotation-driven/>
Oups. Copier-coller question. J'ai été l'exécution d'autres tests quand j'ai écrit cela. J'ai mis à jour le fichier xml.
Alors, avez-vous encore observer SimpleAsyncTaskExecutor fils avec mise à jour de config?
Oui. L'exemple dans mon post, c'est exactement ce que je vois. La méthode asynchrone est exécutée avec la ThreadPoolTaskExecutor défini dans le fichier XML, mais pour quelque raison que ce soit, il y a 4 threads commencé par SimpleAsyncTaskExecutor qui ne font rien.
J'ai juste importé votre fichier config dans mon environnement et je n'ai qu'un thread supplémentaire appelé
executor-1
. Je suppose que vous avez un autre <task:annotation-driven/>
quelque part d'autre ou vous avez un autre printemps contexte. J'ai aussi remarqué que vous exécutez pas le SomeClassTest dans votre eclipse capture d'écran.OriginalL'auteur CAL5101 | 2012-11-15
Vous devez vous connecter pour publier un commentaire.
Tout d'abord, si l'utilisation de Java 5 et au-dessus (nécessaire pour Java contrats à Terme, etc), la valeur par défaut TaskExecutor mise en œuvre devrait être le ThreadPoolTaskExecutor, qui correspond à votre trace de débogage de sortie. C'est le gestionnaire de thread en fait de l'exécution de votre code de test.
La SimpleAsyncTaskExecutor est susceptible d'être lancé dans le cadre du Printemps de l'exécuteur de tâches cadre, éventuellement à partir d'une autre annotation dans votre test fichier de contexte. Le Printemps, le conteneur peut être le lancement de quatre instances de la SimpleAsyncTaskExecutor classe. En fonction de Printemps de la documentation, cette version de la TaskExecutor jamais ré-utilise des threads pour satisfaire les nouvelles demandes (il va commencer un nouveau fil de discussion):
SimpleAsyncTaskExecutor
Référence: http://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/scheduling.html#scheduling-task-executor
Par conséquent, ce pourrait être le résultat d'interactions entre le test contexte et le Printemps conteneur.
Je crois que vous avez un seul thread en cours d'exécution de votre code de test dans ce scénario, qui est ce que vous attendez, basée sur une simple demande. Printemps TaskExecutor implémentations de tirer parti d'une classe d'assistance appelé ConcurrencyThrottleSupport qui est censé gaz (limite) le nombre de threads simultanés dans l'exécution. Dans votre cas, ce devrait être de 2, comme indiqué par la piscine de la taille de la propriété. Cependant, pour exécuter ce un test, il ne faut jamais besoin d'allouer un thread supplémentaire, et la sortie de trace d'accord avec cela.
OriginalL'auteur pmhargis