Acoplamiento bajo que procesa grandes cantidades de datos

8

Por lo general, logro un bajo acoplamiento al crear clases que intercambian listas, conjuntos y mapas entre ellos. Ahora estoy desarrollando una aplicación Java por lotes y no puedo colocar todos los datos dentro de una estructura de datos porque no hay suficiente memoria. Tengo que leer y procesar una parte de los datos y luego pasar a la siguiente. Por lo tanto, tener un acoplamiento bajo es mucho más difícil porque tengo que verificar en algún lugar si todavía hay datos para leer, etc.

Lo que estoy usando ahora es:

Fuente - > Proceso - > Persistir

Las clases que se procesan tienen que preguntar a las clases de origen si hay más filas para leer.

¿Cuáles son las mejores prácticas y / o patrones útiles en tales situaciones?

Espero que me esté explicando, si no me lo dice.

    
pregunta Виталий Олегович 09.04.2012 - 11:05

2 respuestas

7

De los comentarios veo que estás usando Java. Eche un vistazo a varias implementaciones de Queue . En particular, BlockingQueue es útil para productor-consumidor escenarios. Podría tener dos colas: una entre Fuente (productor de datos) y Proceso (consumidor de datos), y otra entre Proceso (productor de resultados) y Persistir (consumidor de resultados).

Con las colas de bloqueo de capacidad limitada es bastante fácil de implementar sistemas eficientes (la parte del cuello de botella, sea lo que sea, se mantiene alimentada con datos el 100% del tiempo), y sigue usando solo una cantidad limitada de memoria, independientemente de la cantidad de datos. hay.

    
respondido por el Joonas Pulakka 09.04.2012 - 12:15
2

Una cola de bloqueo (de Joonas Pulakka) es la respuesta de trabajo pesado. Una respuesta más simple podría funcionar. Si tiene todos los datos almacenados en la fuente, solo puede pasar una referencia al procesador, y puede simplemente sacar los datos de la fuente. Por supuesto, esto es probablemente lo que estabas haciendo en el pasado. Es posible que no tenga todos los datos en la memoria en la fuente y que no obtenga el acoplamiento bajo que desea.

El siguiente paso sería utilizar una interfaz de enumerador o iterador. (Los iteradores son más comunes en Java, aunque la mayoría de las veces el método remove es solo un nusancia). El procesador obtendría el iterador de la fuente y luego llamará a los métodos hasta que termine. Si la fuente está extrayendo terrabytes de datos de algún lugar, cada llamada puede tomar un tiempo. Pero si va a dormir en el procesador hasta que haya algo en la cola de todos modos, esto lo hará automáticamente. Y si la fuente se adelanta al productor, la fuente esperará automáticamente a que el productor llame a hasNext y next .

Si, por otro lado, desea que la fuente tome datos de su fuente tan rápido como sea posible y que los almacene hasta que el procesador se ponga al día, no está sentado a la espera de que el procesador se procese, luego la cola y varios subprocesos comienzan a parecer una buena idea, aunque más complicada. Ahora, la fuente puede acumular los datos cuando puede ejecutarse más rápido (su límite probablemente sea algo como la E / S del disco), y el procesador puede reducir el tamaño de la pila cuando it puede ejecutarse más rápido, ( su límite es la rapidez con la que el módulo de persistencia puede conservar los datos).

    
respondido por el RalphChapin 09.04.2012 - 17:35