Questione : ConcurrentLatch in Java.

È questo un'esecuzione corretta del fermo simultaneo?

In il piano d'azione sotto, voglio il isEligibleForClearDown () essere funzionato simultaneamente. Prego suggest.

mentre (iterator! = && nullo iterator.hasNext ()) {startLatch finale del
CountDownLatch = nuovo CountDownLatch (filetti);
per (int i = 0; i < 10; i++) {executorService del
ExecutorService = Executors.newFixedThreadPool (threads); inizio 10 threads.
di // se (iterator.hasNext ()) {modello finale del
OrderModel = (OrderModel) iterator.next ();
executorService.execute (new praticabile () {vuoto del pubblico del
funzionano () {calendario del
ora = Calendar.getInstance (TimeZone.getTimeZone (“Europe/London"));
se (isEligibleForClearDown (model, master.getCleardownFields () .getClearDownReqFrom (), ora)){
se (model.getOrderFields () .hasParentOrderId ()){
//add tutti gli ordini del bambino a result
results.add (modello);
} altrimenti {ordini del genitore del
//add al list
parentOrders.add (modello) del genitore;
startLatch.countDown del
del
}} ();
del
}});
} altrimenti {
se (startLatch.getCount () > 0) {contatore di decremento di // fino a che il fermo non sia prova di zero.
{
startLatch.await (); fermo del
} (InterruptedException e) {
LOGGER.error (“eccezione interrotta mentre aspettando il fermo di conto alla rovescia a end."); prova del
del
del
del
del
}}}} {
startLatch.await (); l'attesa di // fino a che i primi 10 filetti non completassero il fermo di processing.
} (InterruptedException e) {
LOGGER.error (“ha interrotto l'eccezione mentre aspettava il fermo di conto alla rovescia a end.");
} del
} class= del

Risposta : ConcurrentLatch in Java.

La prima cosa che suggerirei sta spostando il vostro servizio dell'esecutore fuori del ciclo.  Dovete realmente soltanto generare una volta quello.  Secondo la vostra esecuzione, potete potere rendergli una variabile del codice categoria, l'una o l'altra un'elettricità statica che è ripartita da tutti i casi di questo codice categoria o di un membro riservato se ogni codice categoria ha bisogno del relativo proprio stagno del filetto.  Il uno o il altro senso, finchè non chiudete il servizio giù, potrete riutilizzare quei filetti invece di subire le spese generali di iniziarli sempre.  Se le chiamate multiple a questo metodo debbano funzionare simultaneamente, spostare la creazione di servizio dell'esecutore nuovamente dentro il metodo, ma fuori del ciclo.

Inoltre assomiglia voi sta generando 10 stagni del filetto, con 10 filetti ciascuno per procedare ogni ordine.  Il codice che ho attaccato è ripreso per procedare tutto ha fornito gli ordini 10 filetti.
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:

codice categoria pubblico ClearDownService {
    filetti riservati di int;
    executorService riservato di ExecutorService;

    ClearDownService pubblico (filetti di int) {
        se (filetti < 1="">= 1. “);
        }
        this.threads = filetti;
        this.executorService = Executors.newFixedThreadPool (this.threads);
    }

    // I ha modificato il vostro codice di ripetizione per presupporre che aveste certa accumulazione degli oggetti di OrderModel
    // che state usando per ottenere il iterator.  Poiché state usando il JDK 1.5+, relativo molto più
    // leggibile e mantenibile usare i Generics invece di lanciare il ritorno di iterator.next ().
    // I inoltre ha modificato il vostro codice di ripetizione per usare la costruzione incorporata del foreach.
    checkOrders vuoti del pubblico (ordini di accumulazione) {
        // inizializza il fermo per il numero totale degli ordini, anziché i filetti.
        // questo assicura che tutti gli ordini siano procedati prima che questo metodo completi
        startLatch finale che di CountDownLatch = nuovo CountDownLatch (orders.size ());

        // poiché state usando il JDK 1.5+, più facile leggere ed effettuare se usate i generics
        // e il foreach incorporato anziché il iterator
        per (modello finale di OrderModel: ordini) {
            executorService.submit (nuovo praticabile () {
                vuoto del pubblico funzionato () {
                    prova {
                        Calendario ora = Calendar.getInstance (TimeZone.getTimeZone (“Europa/Londra„));
                        se (isEligibleForClearDown (modello, master.getCleardownFields () .getClearDownReqFrom (), ora)) {
                            se (model.getOrderFields () .hasParentOrderId ()) {
                                // aggiunge tutti gli ordini del bambino al risultato finale
                                results.add (modello);
                            } altrimenti {
                                // aggiunge gli ordini del genitore alla lista di genitore
                                parentOrders.add (modello);
                            }
                        }
                    } infine {
                        // che mette questo infine in un blocco assicura che ottenga denominato con noncuranza
                        // di qualsiasi eccezioni che si presentano nel corpo del metodo
                        startLatch.countDown ();
                    }
                }
            });
        }
        prova {
            startLatch.await (); aspettare di // tutti gli oggetti all'elaborazione completa
        } fermo (InterruptedException e) {
            LOGGER.error (“eccezione interrotta mentre aspettando il fermo di conto alla rovescia a end.");
        }
    }
}
Altre soluzioni  
 
programming4us programming4us