Fråga : ConcurrentLatch i Java.

Är detta som ett korrekt genomförande av concurrenten låsa?

In det nedanföra scenariot, jag önskar att isEligibleForClearDownen () ska köras samtidigt. Behaga stunder för suggest.

(iterator! = ogiltig && iterator.hasNext ()) {finalCountDownLatch för
startLatch = nya CountDownLatch (trådar);
för (int i = 0; i < 10; i++) {executorService för
ExecutorService = Executors.newFixedThreadPool (threads); // start 10 threads.
, om (iterator.hasNext ()) {den
finalen OrderModel modellerar = (OrderModel) iterator.next ();
executorService.execute (Runnable new () {körningen för allmänhet för
den utan laga kraft () {kalendern för
nu = Calendar.getInstance (TimeZone.getTimeZone (”Europe/London”));
, om (isEligibleForClearDown (model, master.getCleardownFields () .getClearDownReqFrom (), nu)){
, om (model.getOrderFields () .hasParentOrderId ())(modellera), {
//add som allt barn beställer till finalresult
results.add;
} annars {den
//add föräldern beställer till förälderlist parentOrders.add (modellera);
startLatch.countDown för
för
}} ();
för
}});
} annars {
om (startLatch.getCount () > 0) {// förminskar kontrar, tills låsa är försök för zero.
{
startLatch.await ();
} fångar (InterruptedException e) {
LOGGER.error (”avbrutna undantagsstunder som väntar nedräkningen, låser för att avsluta. ”); försök för
för
för
för
för
}}}} {
startLatch.await (); den // väntan, tills de första 10 trådarna färdig processing.
} fångar (InterruptedException e) {
LOGGER.error (”, avbrutna undantagsstunder som väntar nedräkningen, låser för att avsluta. ”);
} för
} " klar "

Svar : ConcurrentLatch i Java.

Första ting som jag skulle rekommenderar är röra din tjänste- executor förutom kretsa.  Du behöver egentligen endast att skapa det en gång.  Beroende av ditt genomförande du kan vara kompetent att göra det en klassificeravariabel som är antingen en statisk elektricitet alla som delas av anföra som exempel av denna klassificerar, eller en privat medlem, om varje klassificerar behov dess egna tråd slår samman.  Endera långt, så länge som du inte stänger det tjänste-, besegrar, dig ska är kompetent att återanvända de trådar, i stället för att åsamka sig fast utgift av start dem varje tid.  Om multipelappeller till denna ska metod behöver att köra samtidigt, flyttningen den tjänste- skapelsebaksidaen för executoren in i metoden, men förutom kretsa.

Den ser också något liknande som du skapar 10 trådtips, med 10 trådar varje för att bearbeta varje beställer.  Kodifiera som jag har fäst, omarbetas för att bearbeta förutsatt att alla beställer med 10 trådar.
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:

allmänhet klassificerar ClearDownService {
    privata int-trådar;
    privat ExecutorService executorService;

    offentliga ClearDownService (int-trådar) {
        om (trådar < 1="">= 1. ”);
        }
        this.threads = trådar;
        this.executorService = Executors.newFixedThreadPool (this.threads);
    }

    // I ändrade din upprepning kodifierar för att anta att du har någon samling av OrderModel anmärker
    // att du använder för att få iteratoren.  Sedan du använder JDK 1.5+ som är dess mycket mer
    försvarbar // som är läslig och att använda Generics i stället för rollbesättning returen av iterator.next ().
    // I ändrade också din upprepning kodifierar för att använda den inbyggde foreachtankeskapelsen.
    offentliga utan laga kraft checkOrders (samlingen beställer) {
        // initialiserar låser för slutsumman numrerar av beställer, i stället för trådar.
        // som detta ser till att allt beställer bearbetas, för denna metod avslutar
        finalCountDownLatch startLatch = nya CountDownLatch (orders.size ());

        //, sedan du använder JDK 1.5+ som är lättare att läsa och underhålla, om du använder generics
        // och den inbyggde foreachen i stället för iteratoren
        för (finalen OrderModel modellerar: beställer) {
            executorService.submit (nya Runnable () {
                offentligt annullera körningen () {
                    försök {
                        Kalender nu = Calendar.getInstance (TimeZone.getTimeZone (”Europa/London”));
                        om (isEligibleForClearDown (modellera, master.getCleardownFields () .getClearDownReqFrom (), nu)), {
                            om (model.getOrderFields () .hasParentOrderId ()) {
                                // tillfogar allt barn beställer till finalresultatet
                                results.add (modellera);
                            } annars {
                                // tillfogar föräldern beställer till föräldern listar
                                parentOrders.add (modellera);
                            }
                        }
                    } slutligen {
                        // som sätter denna i ett kvarter, ser till slutligen att det får kallat utan hänsyn
                        // av några undantag som uppstår i förkroppsliga av metoden
                        startLatch.countDown ();
                    }
                }
            });
        }
        försök {
            startLatch.await (); den // alla väntan för anmärker för att avsluta att bearbeta
        } fånga (InterruptedException e) {
            LOGGER.error (”avbrutna undantagsstunder som väntar nedräkningen, låser för att avsluta. ”);
        }
    }
}
Andra lösningar  
 
programming4us programming4us