Modo mobilizável do Futuro

　　maneiras de Tópicos:
                1. herda classe Thread
                2. implementar Runnable
                3. piscina Tópico
                4.Callable

　　Independentemente da herança classe Thread ou implementar a interface Runnable, ou usar o pool de threads é nenhuma maneira de resolver dois problemas
                1. thread de execução não retorna um valor de resultado
                2. execução da linha é nenhuma maneira de lançar uma exceção, só pode ser resolvido através de sua própria try-catch

 

　　Mobilizável e Runnable Da mesma forma, no pacote JUC, as principais mentiras diferença na chamada de método que pode ser chamado pode retornar o valor e pode lançar exceções
       se exigível desejado realizada, necessidade de apoio Futuro classe de implementação, capaz de receber o resultado valor de retorno, classe de implementação Futuro é um FutureTask,

 

　　primeira chamada pode ser chamado de implementação:

                público  classe MyCallable os instrumentos resgatáveis <string> { 
                    @Override 
                    pública de Cordas Call () lança Exceção { 
                        System.out.println ( "Call mobilizável interface do método de reescrita, pode haver um valor de retorno e lança uma exceção" );
                         retorno "mobilizável" ; 
                    } 

                    público  estáticos  vazios principais (String [] args) lança ExecutionException, InterruptedException { 
                        myCallable myCallable = new new myCallable ();
                         //uso mobilizável execução FutureTask e aceita os resultados 
                        FutureTask <String> = stringFutureTask nova nova FutureTask <> (myCallable);
                         // usar o fio para executar tarefas Task 
                        nova nova .start a Thread (stringFutureTask) ();
                         // aceitar os resultados FutureTask.get obstrução acontece 
                        Sistema .out.println (stringFutureTask.get ()); 

                        System.out.println ( "MyCallable acabado, devolver o valor do resultado recebido corretamente ~" ); 
                    } 
                }

 

         A segunda chamada implementação mobilizável:

                pública  estática  vazios principais (String [] args) lança ExecutionException, InterruptedException { 
                    MyCallable myCallable = new new MyCallable ();
                     // criar um pool de threads 
                    ExecutorService ExecutorService = Executors.newFixedThreadPool (3 );
                     // criar um thread para executar a tarefa, dada a resultados de tarefas 
                    Futuro <string> Futuro = ExecutorService.submit (myCallable);
                     // aceita valor de retorno 
                    System.out.println (Future.get (2000 , TimeUnit.MILLISECONDS)); 
                    System.out.println ("Modo piscina 2 Tópico: MyCallable acabado, devolver o valor do resultado recebido corretamente ~" );
                     // parada segmento pool 
                    executorService.shutdown (); 
                }

 

            Future.get () para obter os resultados de execução da tarefa, quando o método se não retorno, estado temporariamente bloqueada
            Future.get (Long timeOut, TimeUnit TimeUnit) pode definir o tempo limite
            Future.boolean isDone () se a ponta da linha, se é o fim do normal ou término da tarefa retornará true
            Future.boolean isCanceller () é cancelada antes que a tarefa é concluída se ele retorna true
            Future.boolean o método (boolean Flag) cancelar se o parâmetro de entrada é verdadeiros representantes da tarefa de interrupção, se a tarefa for interrompida êxito, o valor de retorno é verdadeiro e false se ele falhar

 

　　　Futuro fornece três funções: cancelar uma tarefa de interrupção (true) 2. determinar se a tarefa estiver concluída isDone () 3. Obter os resultados obter a execução da tarefa ()

// tarefa de interrupção 
                Boolean Cancel = Future.cancel ( a verdade );
                 IF (Cancelar) { 
                    System.out.println ( "tarefa de interrupção com sucesso ~" ); 
                } else {
                     // aceitar o valor de retorno 
                    System.out.println (future.get (2000 , TimeUnit.MILLISECONDS)); 

                }

 

Se a caligrafia modelos futuros devem ser como definir?

esperar a cargo de obstrução e avisar evocar responsável bloqueado fio

                público  classe MyFuture {
                     // as corresponde sinalizador para os dados de identificação, se os dados em sucesso, retorna ao verdadeiro, caso contrário retorna false 
                    Privada  estática  booleana o FLAG = false ;
                     Privada dados de cadeia; 

                    pública  a sincronizado  vazio do setData (Dados String) lança InterruptedException { 
                        Thread de latência ( 2000 );
                         // atribuição 
                        a este .data = dados; 
                        o FLAG = true ;
                         // Arouse
                        notificar (); 
                    } 

                    Pública  sincronizado Cordas getData () {
                         // 如果获取数据失败
                        se (! FLAG) {
                             try { 
                                wait (); 
                            } Captura (InterruptedException e) { 
                                e.printStackTrace (); 
                            } 
                        } 
                        Retornar dados; 
                    } 

                    Público  estáticos  vazios principais (String [] args) { 
                        MyFuture futuras =novo MyFuture ();
                        novo Thread (() -> {
                             try { 
                                future.setData ( "张三" ); 
                                System.out.println (future.getData ()); 
                            } prendedor (InterruptedException e) { 
                                e.printStackTrace (); 
                            } 
                        }). começar(); 
                    } 
                }