Dicas de codificação de programas java no cenário multicore [fechado]

StackOverflow https://stackoverflow.com/questions/601491

Pergunta

Parece haver um monte de barulho sobre multicore e java. Enquanto algumas pessoas dizem que o apoio java não é bom o suficiente , ele definitivamente parece ser uma área para olhar para frente. Parece haver muitos técnicas para melhorar o desempenho de programas concorrentes.

Todas as dicas / conselhos sobre a programação em um cenário multi core é apreciado.

Foi útil?

Solução

Olhe para as novas instalações de simultaneidade de Java (na java.util.concurrent pacote ) que foram adicionados em Java 5. ele fornece funcionalidade que é mais alto nível do que Threads regulares que vão torná-lo mais fácil (e menos propenso a erros) para escrever aplicativos simultâneos. A Lição: Simultaneidade de Os tutoriais Java seria um bom lugar para começar.

Até agora, eu só usei o ExecutorService , que permite que pode produzir pools de threads , para que novas tarefas podem ser entregue em unidades de Runnable s ou Callable s (que podem retornar valores após a execução como Future s), eo código de segmentação real é tratado pelo ExecutorService.

Por exemplo, realizando alguns cálculos usando um pool de threads de 2 fios, e obtendo o resultado pode ser tão simples como: 

ExecutorService es = Executors.newFixedThreadPool(2);

Future f1 = es.submit(new Callable<Integer>() {
    public Integer call()
    {
        // Do some processing...
        return someInteger;
    }
});

Future f2 = es.submit(new Callable<Integer>() {
    public Integer call()
    {
        // Do some processing...
        return someInteger;
    }
});

Integer firstInteger = f1.get();
Integer secondInteger = f2.get();

No código acima (não testado), tudo o que tem que se preocupar é fazer um par de Callables e submit ing-lo para o ExecutorService e mais tarde, usando os Futures para recuperar o resultado.

O problema é, uma vez que a método get do Future é chamado, se o processamento não está completo, o programa vai parar até que o resultado do Future pode ser recuperada. Assim, neste exemplo, mesmo se o resultado de f2 está disponível antes f1, o programa irá esperar até que o resultado de f1 está disponível.

Em termos de material de leitura, na minha lista de livros para compra em breve é ?? Java Concurrency in Practice por Brian Goetz, que surge muitas vezes quando a simultaneidade em Java é levantada.

Concorrência Utilities da documentação Java 5 tem mais informações também.

Outras dicas

A melhor dica tem que ser: obter a sua sincronização correta

Isto pode parecer um pouco óbvio, mas uma compreensão da href="http://en.wikipedia.org/wiki/Java_Memory_Model" rel="nofollow noreferrer"> Java Memory Model é vital, particularmente como volátil e final campos de trabalho, como sincronizados atua como um mutex e a barreira de memória e, em seguida, as novas construções java.util.concurrent bem

Sempre uma boa dica -. Se a maioria de suas classes são imutáveis ??tudo se torna muito mais fácil quanto imutabilidade elimina a necessidade de se preocupar com bloqueios de muitos para poucos lugares de interesse

Confira a próxima fork-join framework . A estrutura fork-join permite aos desenvolvedores atingir o paralelismo de grão fino em multicore arquiteturas.

Além disso, você pode querer verificar para fora JVM linguagens baseadas como Clojure que pretendem fazer multicore paralelo a programação mais fácil.

Como alternativa à própria abordagem de memória compartilhada do Java para a simultaneidade você também pode olhar para -ator base de simultaneidade usando Scala em cima de Java, que fornece um modelo mais fácil para programação concorrente.

Confira a palestra de Brian Goetz de simultânea para Paralela de Devoxx 2008. Não muitas dicas lá, mas ela lhe dá uma idéia de onde a simultaneidade Java está se dirigindo para.

Você pode tentar usar um padrões de paralelismo biblioteca, como Skandium para Java. Basta escolher o padrão de paralelismo que você quer e preencher os ganchos desaparecidas.

Alguns dos padrões sopported em Skandium são:

  • mestre-escravo: Farm<P,R>(nested);
  • Pipeline: `tubulação (stage1, stage2);
  • Para iteração: For<P,R>(nested, i);
  • Conditional iteração: While<P,R>(nested, condition);
  • condicional ramificação: If<P,R>(condition, trueCase, falseCase);
  • Map-Reduce: Map<P,R>(split, nested, merge);
  • Map-Reduce com diferentes caminhos de código: Fork<P,R>(split, nested, merge);
  • divisão recursiva e conquista: DaC<P,R>(condition, split, nested, merge);

Todos os padrões podem ser aninhados e combinar, de modo que você pode ter dentro de fazenda de um dividir e conquistar, etc.

A melhor livro com dicas práticas tem sido Java Concurrency in Practice . É uma leitura obrigatória para todos os programadores Java, mesmo aqueles que acha que eles não fazem qualquer tipo de programação concorrente, porque java tem muitas rosqueamento escondido em suas diversas bibliotecas (balanço vem à mente, mesmo com servlets).

A minha dica: Entenda o Java Memory Model (desde JDK 5 ou superior). A maioria das pessoas não sabe, que a sincronização, volátil e último tem um significado adicional para além do âmbito normal-threading múltiplas.

Java é bom para multi-cpu e multi-núcleos. Se você programá-lo direito e você investir algum cérebro, você tem um sistema de servidor altamente concorrente de utilizar 8 núcleos, incluindo um monte de sincronização e assim por diante. Estamos muito felizes com ele ... JDK6 é melhor do que JDK5 e tudo abaixo suga em máquinas multi-CPU.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top