2009-05-12 29 views
24

Estoy tratando de entender cómo implementar el subproceso en una aplicación Java que utiliza Spring para la administración de transacciones. Encontré la sección TaskExecutor en el Spring documentation, y ThreadPoolTaskExecutor parece que se ajusta a mis necesidades;¿Algún buen hilo de resorte con ejemplos de TaskExecutor?

ThreadPoolTaskExecutor

Esta aplicación sólo se puede utilizar en un entorno Java 5, pero también es el más comúnmente utilizado uno en ese entorno. Expone propiedades de beans para configurar un java.util.concurrent.ThreadPoolExecutor y lo envuelve en un TaskExecutor. Si necesita algo avanzado, como un ScheduledThreadPoolExecutor, se recomienda utilizar un ConcurrentTaskExecutor.

Sin embargo, no tengo ni idea de cómo usarlo. He estado buscando buenos ejemplos por un tiempo sin suerte. Si alguien puede ayudarme, lo agradecería.

Respuesta

33

Es bastante simple. La idea es que tienes un objeto ejecutor que es un bean, que se pasa al objeto que quiera disparar la nueva tarea (en un nuevo hilo). Lo bueno es que puedes modificar qué tipo de ejecutor de tareas usar simplemente cambiando las configuraciones de Spring. En el siguiente ejemplo, tomo una clase de ejemplo (ClassWithMethodToFire) y la envuelvo en un objeto Runnable para activar el fuego; también podría implementar Runnable en una clase propia, y luego en el método de ejecución simplemente llamaría al classWithMethodToFire.run().

Aquí hay un ejemplo muy simple.

public class SomethingThatShouldHappenInAThread { 
    private TaskExecutor taskExecutor; 
    private ClassWithMethodToFire classWithMethodToFire; 

    public SomethingThatShouldHappenInAThread(TaskExecutor taskExecutor, 
               ClassWithMethodToFire classWithMethodToFire) { 
      this.taskExecutor = taskExecutor; 
      this.classWithMethodToFire = classWithMethodToFire; 
    } 

    public void fire(final SomeParameterClass parameter) { 
      taskExecutor.execute(new Runnable() { 
       public void run() { 
        classWithMethodToFire.doSomething(parameter); 
       } 
      }); 
    } 
} 

Y aquí están los granos de primavera:

<bean name="somethingThatShouldHappenInAThread" class="package.name.SomethingThatShouldHappenInAThread"> 
    <constructor-arg type="org.springframework.core.task.TaskExecutor" ref="taskExecutor" /> 
    <constructor-arg type="package.name.ClassWithMethodToFire" ref="classWithMethodToFireBean"/> 
</bean> 

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> 
    <property name="corePoolSize" value="5" /> 
    <property name="maxPoolSize" value="10" /> 
    <property name="queueCapacity" value="25" /> 
</bean> 
+0

Creo que mi problema es pensar que esto es más complejo, entonces es. Vi http://docs.huihoo.com/javadoc/spring/2.0/org/springframework/scheduling/concurrent/ThreadPoolTaskExecutor.html#createQueue(int) y asumí que ThreadPoolTaskExecutor tenía un mecanismo de cola incorporado. –

+0

Tal vez no me he confundido, ¿para qué es QueueCapacity? Todavía siento que me falta algo aquí. –

+12

Si la capacidad de cola es mayor que 0, crea una cola, de modo que las tareas que activa un TaskExecutor en particular pueden esperar hasta que haya un subproceso disponible desde el grupo. La capacidad indica cuántos espacios hay en la cola. Si la cola se llena, el ejecutor bloqueará (es decir, el método de ejecución no volverá hasta que se abra un espacio). Aquí está el documento en la cola: http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/LinkedBlockingQueue.html –

Cuestiones relacionadas