2011-02-06 16 views
14

mi pregunta es si existe un marco en Java para administrar y ejecutar simultáneamente tareas que tienen dependencias lógicas.Java Framework para la administración de tareas

Mi tarea es la siguiente: Tengo un montón de tareas independientes (digamos A, B, C, D ...), se implementan como comandos (como en el patrón de comando). Me gustaría tener un tipo de ejecutor que acepte todas estas tareas y las ejecute de forma paralela. Las tareas pueden ser dependientes una de otra (por ejemplo, no puedo ejecutar C, antes de ejecutar A), sincrónico o asincrónico.

También me gustaría incorporar la heurística personalizada para afectar la ejecución del planificador, por ejemplo, si las tareas A y B requieren mucha CPU y C tiene, por ejemplo, un consumo de memoria alto, tiene sentido ejecutar A y C en paralelo, en lugar de ejecutar A y B.

Antes de meterme en la creación de estas cosas por mi cuenta (estoy pensando en java.util.concurrent + restricciones/reglas basadas en anotaciones), me preguntaba si alguien podría señalarme algún proyecto que pueda satisfacer mis necesidades Muchas gracias de antemano

+0

Echa un vistazo a Fork/Join? –

+0

Me pregunto si las tareas se reutilizan entre sí resultados o no. Si son unidades de trabajo bastante independientes con una secuencia predefinida, la programación y la heurística personalizada podrían resolverse con un ejecutor de agrupaciones de hilos personalizado bastante simple. –

+0

Sí, también estoy pensando en usar los Servicios de Ejecutor de java.util.concurrent, las tareas parecen ser independientes en términos de reutilizar los resultados de cada uno. Debería echar un vistazo a tenedor/unirse como Viktor Klang amablemente propuso también. –

Respuesta

7

No creo que haya un marco para la gestión de tareas que puedan cumplir sus requisitos. Estás en el camino correcto con el patrón Command. Puede echar un vistazo a Akka framework para obtener un modelo de simultaneidad simplificado. Akka se basa en el modelo de actor:

El modelo de actor es otro modelo muy simple concurrencia alto nivel: actores no pueden responder a más de un mensaje a la vez (los mensajes se ponen en cola en buzones) y solo puede comunicarse por enviando mensajes, sin compartir las variables . Siempre y cuando los mensajes son estructuras de datos inmutables (que es siempre es cierto en Erlang, pero tiene que ser una convención en idiomas sin medios de asegurar esta propiedad), todo es seguro para subprocesos, sin necesidad de ningún otra mecanismo. Esto es muy similar para solicitar el ciclo que se encuentra en la web frameworks de desarrollo MVC. http://metaphysicaldeveloper.wordpress.com/2010/12/16/high-level-concurrency-with-jruby-and-akka-actors/

Akka está escrito en Scala, sino que expone la API de Java limpia.

2

Le recomiendo que examine la posibilidad de utilizar ant para este fin. Aunque ant se conoce como una popular herramienta de compilación, en realidad es el motor controlado por XML que ejecuta varias tareas. Creo que su indicador fork=true hace exactamente lo que necesita: ejecuta tareas al mismo tiempo. Como cualquier aplicación java ant se puede ejecutar desde otra aplicación java: simplemente llame al método main. En este caso, puede ajustar sus tareas utilizando Ant API, es decir, implementarlas como tareas Ant.

Nunca he intentado este enfoque, pero creo que debería funcionar. Lo pensé hace varios años y se lo sugerí a mi gerencia como una posible solución para un problema similar al suyo.

+0

Sí, pensé en esta opción también. Parece que se adapta a mis necesidades, pero a su manera :) Parece una herramienta incorrecta para resolver esto. Las tareas ya están escritas (es parte de un gran código listo para la producción). Entonces, presentar una hormiga solo para resolver esto suena como una exageración. ¡Gracias por el consejo! –

+0

No mencionar. Estoy parcialmente de acuerdo contigo cuando dices que la hormiga es una herramienta equivocada. Creo que usar hormiga aquí es su abuso. Pero creo que a veces el abuso de API puede ser útil. Incluso escribí un artículo sobre esto: http://java.dzone.com/articles/useful-abuse – AlexR

0

Existe un marco específicamente para este propósito llamado dexecutor (exención de responsabilidad: yo soy el propietario)

Dexecutor es un marco muy ligero para ejecutar tareas dependientes/independientes de una manera fiable, para hacer esto proporciona a la API mínima

  • una API para añadir nodos en el gráfico (addDependency, addIndependent, addAsDependentOnAllLeafNodes, addAsDependencyToAllInitialNodes Más tarde dos son la versión híbrida de la primera dos)
  • y el otro para ejecutar los nodos en orden.

Aquí es el ejemplo más sencillo:

DefaultDependentTasksExecutor<Integer, Integer> executor = newTaskExecutor(); 

    executor.addDependency(1, 2); 
    executor.addDependency(1, 2); 
    executor.addDependency(1, 3); 
    executor.addDependency(3, 4); 
    executor.addDependency(3, 5); 
    executor.addDependency(3, 6); 
    //executor.addDependency(10, 2); // cycle 
    executor.addDependency(2, 7); 
    executor.addDependency(2, 9); 
    executor.addDependency(2, 8); 
    executor.addDependency(9, 10); 
    executor.addDependency(12, 13); 
    executor.addDependency(13, 4); 
    executor.addDependency(13, 14); 
    executor.addIndependent(11); 


    executor.execute(ExecutionBehavior.RETRY_ONCE_TERMINATING); 

Aquí está cómo el gráfico de dependencias se construiría enter image description here

Tareas 1,12,11 corrían en paralelo, una vez en una de estas tareas finaliza la ejecución de las tareas dependientes, por ejemplo, digamos que la tarea 1 finaliza, las tareas 2 y 3 se ejecutarán de manera similar una vez que la tarea 12, la tarea 13 finalice y así sucesivamente.

Cuestiones relacionadas