Cuestión : ConcurrentLatch en Java.

¿Está esto una puesta en práctica correcta de cierre concurrente? el

In el panorama below, quisiera que el isEligibleForClearDown () fuera funcionado simultáneamente. ¡Por favor suggest.

mientras que (iterator! = && nulo iterator.hasNext ()) {startLatch final del
CountDownLatch = nuevo CountDownLatch (hilos de rosca);
para (internacional i = 0; i < 10; i++) {executorService del
ExecutorService = Executors.newFixedThreadPool (threads); comienzo 10 threads.
de // si (iterator.hasNext ()) {modelo final del
OrderModel = (OrderModel) iterator.next ();
executorService.execute (new Runnable () {vacío del público del
funcionan () {calendario del
ahora = Calendar.getInstance (TimeZone.getTimeZone (“Europe/London"));
si (isEligibleForClearDown (model, master.getCleardownFields () .getClearDownReqFrom (), ahora)){
si (model.getOrderFields () .hasParentOrderId ()){
//add todas las pedidos del niño al result
results.add (modelo);
} {pedidos del padre del
//add al list
parentOrders.add (modelo) del padre;
startLatch.countDown del
del
}} ();
del
}});
} {
si (startLatch.getCount () > 0) {contador del decremento de // hasta que el cierre sea intento de zero.
{
startLatch.await (); retén del
} (InterruptedException e) {
LOGGER.error (“excepción interrumpida mientras que espera el cierre de la cuenta descendiente a end."); intento del
del
del
del
del
}}}} {
startLatch.await (); la espera de // hasta que los primeros 10 hilos de rosca terminen el retén de processing.
} (InterruptedException e) {
LOGGER.error (“interrumpió la excepción mientras que esperaba el cierre de la cuenta descendiente a end.");
} del
} class= del

Respuesta : ConcurrentLatch en Java.

La primera cosa que recomendaría está moviendo su servicio del ejecutor fuera del lazo.  Usted necesita realmente solamente crear eso una vez.  Dependiendo de su puesta en práctica, usted puede poder hacerle una variable de la clase, cualquiera los parásitos atmosféricos que son compartidos por todos los casos de esta clase o de un miembro privado si cada clase necesita su propia piscina del hilo de rosca.  Cualquier manera, mientras usted no cierre el servicio, usted podrá reutilizar esos hilos de rosca en vez de incurrir en los gastos indirectos de comenzarlos cada vez.  Si las llamadas múltiples a este método necesitan funcionar simultáneamente, mover la creación del servicio del ejecutor nuevamente dentro del método, pero fuera del lazo.

También parece usted está creando 10 piscinas del hilo de rosca, con 10 hilos de rosca cada uno para procesar cada orden.  El código que he atado se vuelve a trabajar para procesar todo proveyó de órdenes 10 hilos de rosca.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:

clase pública ClearDownService {
    hilos de rosca privados de la internacional;
    executorService privado de ExecutorService;

    ClearDownService público (hilos de rosca de la internacional) {
        si (hilos de rosca < 1="">= 1. “);
        }
        this.threads = hilos de rosca;
        this.executorService = Executors.newFixedThreadPool (this.threads);
    }

    // I modificó su código de la iteración para asumir que usted tiene cierta colección de objetos de OrderModel
    // que usted está utilizando para conseguir el iterator.  Puesto que usted está utilizando JDK 1.5+, su mucho más
    // legible y conservable utilizar productos genéricos en vez de echar la vuelta de iterator.next ().
    // I también modificó su código de la iteración para utilizar la construcción incorporada del foreach.
    checkOrders vacíos del público (órdenes de colección) {
        // inicializa el cierre para el número total de órdenes, en vez de los hilos de rosca.
        // que esto se asegura que todas las órdenes estén procesadas antes de que este método termine
        startLatch final de CountDownLatch = nuevo CountDownLatch (orders.size ());

        // puesto que usted está utilizando JDK 1.5+, más fácil leer y mantener si usted utiliza productos genéricos
        // y el foreach incorporado en vez del iterator
        para (modelo final de OrderModel: órdenes) {
            executorService.submit (nuevo Runnable () {
                vacío del público funcionado con () {
                    intento {
                        Calendario ahora = Calendar.getInstance (TimeZone.getTimeZone (“Europa/Londres”));
                        si (isEligibleForClearDown (modelo, master.getCleardownFields () .getClearDownReqFrom (), ahora)) {
                            si (model.getOrderFields () .hasParentOrderId ()) {
                                // agrega todas las pedidos del niño al resultado final
                                results.add (modelo);
                            } {
                                // agrega pedidos del padre a la lista de padre
                                parentOrders.add (modelo);
                            }
                        }
                    } finalmente {
                        // que pone esto en finalmente un bloque se asegura que consigue llamado cueste lo que cueste
                        // de cuaesquiera excepciones que ocurran en el cuerpo del método
                        startLatch.countDown ();
                    }
                }
            });
        }
        intento {
            startLatch.await (); espera de // para todos los objetos al proceso completo
        } retén (InterruptedException e) {
            LOGGER.error (“excepción interrumpida mientras que espera el cierre de la cuenta descendiente a end.");
        }
    }
}
Otras soluciones  
 
programming4us programming4us