Java multi-threaded várias maneiras de criar

Método um: herança de classe Thread, substituir o método de execução, o método de partida direta é chamado fio abertas.

/ ** 
 * herdar a classe Thread, método de partida direta é chamado fio abertas. 
 * @Author LuRenJia
  * / 
público  classe LeaningThread do estende o segmento {
     pública  vazio run () {
         para ( int i = 0; I <20 é; i ++ ) { 
            System.out.println ( "Eu e Mas este é um repetidor frio e o que importa "? ); 
        } 
    } 

    público  estáticos  vazios principais (String [] args) { 
        LeaningThread Lt = new new LeaningThread (); 
        Lt.start (); 
    } 
}

Método dois: implementar interfaces Runable, substituir o método run, linha aberta, chamando classe Thread início.

/ ** 
 * Interface Execut�el para alcançar multi-threaded, através de um proxy 
 * @author LuRenJia
  * / 
público  classe LeaningRunnable os implementos Executeis {
     público  vazio RUN () {
         para ( int i = 0; I <20 é; i ++ ) { 
            System.out. println ( "mas este é um frio e minhas máquinas de vídeo o que fazer com ele?" ); 
        } 
    } 
    pública  estática  vazios principais (String [] args) {
         new new thread ( new new LeaningRunnable ()) Iniciar () ;. 
    } 
}

Método três: alcançar Callabler chamada de método de interface reescrita, crie uma classe ExecutorService serviço, chamar seu enviar método de fio abertas, encerrar serviços através do seu método de desligamento.

/ ** 
 * implementar a interface Callable para implementar multithreaded 
 * @author LuRenJia
  * / 
público  classe LeaningCallable os instrumentos resgatáveis <string> {
     Privado String nome; 

    pública LeaningCallable (String nome) {
         a este .name = nome; 
    } 

    // override chamada de método , o conteúdo de um segmento de execução, um valor de retorno obtida pelo método get 
    @Override
     pública de Cordas Call () lança Exceção {
         para ( int i = 0; I <20 é; i ++ ) { 
            System.out.println (nome + ":" +", mas que era um frio e eu repetidor o que isso importa? " );
        } 
        Retorno nome; 
    } 

    pública  estática  vazios principais (String [] args) { 
        LeaningCallable LC1 = new new LeaningCallable ( "Thread one" ); 
        LeaningCallable LC2 = new new LeaningCallable ( "Passe dois" ); 
        LeaningCallable LC3 = new new LeaningCallable ( "thread três" ); 

        // criar um serviço de execução 
        ExecutorService Servidor = Executors.newFixedThreadPool (3 ); 

        // submetido ao 
        Futuro <string> result1 = server.submit (LC1); 
        Futuro <string> result2 =server.submit (LC2); 
        Futuro <String> result3 = server.submit (LC3); 

        o try { 
            Cordas TEMP = result1.get (); // Retorna um valor 
            System.out.println ( "valor de retorno é:" + TEMP ); 
        } a captura (InterruptedException E) { 
            e.printStackTrace (); 
        } a captura (ExecutionException E) { 
            e.printStackTrace (); 
        } 
        // perto do serviço 
        server.shutdown (); 
    } 
}

Criar um atalho: expressões uso lambda para criar rapidamente fio simples.

/ ** 
 * expressões lambda: Quando único método interface de classe um pai para ser implementado, uma expressão lambda podem ser utilizadas para simplificar o código 
 * 1. A forma padrão: 
 * () -> { 
 * 
 *} 
 * equivalente a 2 implementa um a subclasse interface. 
 * 
 * Os implementos classe Thread interface Runnable, e esta interface tem um método run a ser implementado. 
 * @Author LuRenJia 
 * 
 * / 
público  classe LeaningLambda2 { 

    pública  estáticos  vazios principais (String [] args) {
         new new Thread ( new new o Runnable () { 
            @Override 
            pública  vazio run () {
                 para ( int i = 0; I <100; I ++ ) { 
                    System.out.println ("Mas este é um frio e minhas máquinas de vídeo o que fazer com ele" ); 
                } 
                
            } 
        }) Iniciar ();. 
        
        // expressões uso lambda para criar rapidamente simples fio 
        novo novo a Thread (() -> {
             para ( int 0 = I; I <100; i ++ ) { 
                System.out.println ( "meu conhecimento que tocou o cego!" ); 
            } 
        }) Iniciar () ;. 
    } 
}