Pergunta : ConcurrentLatch em Java.

É isto uma execução correta da trava simultânea? o

In a encenação below, eu quero o isEligibleForClearDown () ser funcionado simultaneamente. Por favor suggest.

quando (iterator! = && nulo iterator.hasNext ()) {startLatch final do
CountDownLatch = CountDownLatch novo (linhas);
para (int i = 0; i < 10; i++) {executorService do
ExecutorService = Executors.newFixedThreadPool (threads); começo 10 threads.
de // se (iterator.hasNext ()) {modelo final do
OrderModel = (OrderModel) iterator.next ();
executorService.execute (new praticável () {vácuo do público do
funcionam () {calendário do
agora = Calendar.getInstance (TimeZone.getTimeZone (“Europe/London"));
se (isEligibleForClearDown (model, master.getCleardownFields () .getClearDownReqFrom (), agora)){
se (model.getOrderFields () .hasParentOrderId ()){
//add todas as ordens da criança ao result
results.add (modelo);
} mais {ordens do pai do
//add ao list
parentOrders.add do pai (modelo);
startLatch.countDown do
do
}} ();
do
}});
} mais {
se (startLatch.getCount () > 0) {contador do decréscimo de // até que a trava estiver tentativa de zero.
{
startLatch.await (); prendedor do
} (InterruptedException e) {
LOGGER.error (“exceção interrompida ao esperar a trava da contagem regressiva a end."); tentativa do
do
do
do
do
}}}} {
startLatch.await (); a espera de // até que as primeiras 10 linhas terminem o prendedor de processing.
} (InterruptedException e) {
LOGGER.error (“interrompeu a exceção ao esperar a trava da contagem regressiva a end.");
} do
} class= do

Resposta : ConcurrentLatch em Java.

A primeira coisa que eu recomendaria está movendo seu serviço do executor fora do laço.  Você precisa realmente somente de criar uma vez aquele.  Dependendo de sua execução, você pode poder fazer-lhe uma variável da classe, qualquer uma uma estática que esteja compartilhada por todos os exemplos desta classe ou de um membro confidencial se cada classe precisa sua própria associação da linha.  Uma ou outra maneira, contanto que você não fechar o serviço para baixo, você poderá reúso aquelas linhas em vez de incorrer as despesas gerais de começá-las todas as vezes.  Se as chamadas múltiplas a este método precisarão de funcionar simultaneamente, mover a criação do serviço do executor de novo no método, mas fora do laço.

Igualmente olha como você está criando 10 associações da linha, com as 10 linhas cada um para processar cada ordem.  Todo o código que eu uni reworked para processar forneceu ordens as 10 linhas.
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:

classe pública ClearDownService {
    linhas confidenciais do int;
    executorService confidencial de ExecutorService;

    ClearDownService público (linhas do int) {
        se (linhas < 1="">= 1. “);
        }
        this.threads = linhas;
        this.executorService = Executors.newFixedThreadPool (this.threads);
    }

    // I modificou seu código da iteração para supr que você tem alguma coleção de objetos de OrderModel
    // que você se está usando para começ o iterator.  Desde que você está usando JDK 1.5+, seu muito mais
    // legível e maintainable para usar produtos genéricos em vez de moldar o retorno de iterator.next ().
    // I igualmente modificou seu código da iteração para usar a construção interna do foreach.
    checkOrders vagos do público (ordens de coleção) {
        // inicializa a trava para o número total de ordens, em vez das linhas.
        // que isto se assegura de que todas as ordens estejam processadas antes que este método terminar
        startLatch final de CountDownLatch = CountDownLatch novo (orders.size ());

        // desde que você está usando JDK 1.5+, mais fácil ler e manter se você usa produtos genéricos
        // e o foreach interno em vez do iterator
        para (modelo final de OrderModel: ordens) {
            executorService.submit (praticável novo () {
                o vácuo do público funciona () {
                    tentativa {
                        Calendário agora = Calendar.getInstance (TimeZone.getTimeZone (“Europa/Londres”));
                        se (isEligibleForClearDown (modelo, master.getCleardownFields () .getClearDownReqFrom (), agora)) {
                            se (model.getOrderFields () .hasParentOrderId ()) {
                                // adiciona todas as ordens da criança ao resultado final
                                results.add (modelo);
                            } mais {
                                // adiciona ordens do pai à lista de pai
                                parentOrders.add (modelo);
                            }
                        }
                    } finalmente {
                        // que põr este finalmente em um bloco assegura-se de que começ chamado de qualquer maneira
                        // de algumas exceções que ocorrerem no corpo do método
                        startLatch.countDown ();
                    }
                }
            });
        }
        tentativa {
            startLatch.await (); espera de // para todos os objetos ao processamento completo
        } prendedor (InterruptedException e) {
            LOGGER.error (“exceção interrompida ao esperar a trava da contagem regressiva a end.");
        }
    }
}
Outras soluções  
 
programming4us programming4us