Mobilizável - compreensão do modo Futuro do Java

resumo:

　　No entanto, em Java, mas também fornece o uso de operações resgatáveis ​​e futuros para alcançar o acesso aos resultados da tarefa. Mobilizável usado para executar tarefas, para produzir um resultado, e os resultados obtidos para o futuro;

@FunctionalInterface
 pública  de interface Callable <V> {
     / * *
     * Calcula um resultado, ou lança uma exceção se não for possível fazê-lo.
     *
     * @Return calculado resultado
     * @Throws Exceção se não for possível calcular um resultado
     * /
    chamada V () lança excepção;
}

　　Passe maneiras:
　　　　1. herda classe Thread
　　　　2. implementar Runnable
　　　　3. piscina Tópico
　　　　4.Callable
　　independentemente da classe Thread herança ou implementar a interface Runnable, ou usar o pool de threads é nenhuma maneira de resolver dois problemas
　　　　1. thread executa nenhum resultado valor de retorno
　　　　2. execução de thread não é 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 valor e pode lançar uma exceção
　　se exigível desejado realizada, necessidade de apoio Futuro classe de implementação, capazes de receber o resultado valor de retorno, classe de implementação Futuro é um FutureTask,

Modo futuro

　　núcleo futuro Moss em que: além de uma função do tempo de espera, e de tal forma que o período de tempo necessário para esperar o original pode ser usado para tratar outra lógica de negócios;

　　Modo futuro: Para multi-threaded, se você quiser esperar pelos resultados fio um segmento B, em seguida, passe um fio há necessidade de esperar a B, B sabe o resultado do segmento, você pode obter um futuro futuro, e outro segmento B, em seguida, tomar o resultado verdadeiro quando resultados;　

público  classe MyCallable implementos mobilizável {
    @Sobrepor
    pública chamada Object () lança Exceção {
        System.out.println ( "Call interface chamável método reescrita, pode haver um valor de retorno e uma exceção é lançada !!!" );
         retorno "exigível" ;
    }

    // 方案一
    pública  estática  vazios principais (String [] args) lança ExecutionException, InterruptedException {
        MyCallable MyCallable = new new MyCallable ();
         // uso e Estrutura aceitação FutureTask realizado exigível 
        FutureTask <String> = stringFutureTask nova nova FutureTask <String> (myCallable);
         // use um fio de tarefa tarefas de execução 
        novo novo a Thread (stringFutureTask) .start ();
         / / aceitar os resultados, obter método bloqueia acontecer 
        System.out.println (stringFutureTask.get ());
        System.out.println ( "mycallable Está consumado!" );
    }

}

 

 

público  classe MyCallable implementos mobilizável {
    @Sobrepor
    pública chamada Object () lança Exceção {
        System.out.println ( "Call interface chamável método reescrita, pode haver um valor de retorno e uma exceção é lançada !!!" );
         retorno "exigível" ;
    }

    // 方案二: submit (tarefa mobilizável) 
    público  estáticos  vazios principais (String [] args) lança ExecutionException, InterruptedException {
        MyCallable MyCallable = new new MyCallable ();
         // criar um segmento 
        ExecutorService ExecutorService = Executors.newFixedThreadPool (3 );
         // criar tópicos mandato e para receber os resultados da tarefa 
        Futuro da Submit = ExecutorService.submit (myCallable);
         // aceitar o valor de retorno, get método bloqueia o fio corrente 
        System.out.printlnl (submit.get ());
        System.out.println ( "usando o pool de threads para executar mycallable, terminou !!!" );
         // parada 
        executorService.shutdown ();
    }
}

　　Os métodos mais comuns:

　　　　V get (): Obtém os resultados de execução assíncrono, se não houver resultados disponíveis, este método bloqueia até que a computação assíncrona é concluída;

　　　　V get (Longo tempo de espera, a unidade TimeUnit): assíncrona obter os resultados, se não yo resultados estão disponíveis, este método vai bloquear, mas existe um limite de tempo, se o tempo de bloqueio excede o tempo conjunto de tempo limite, o método gera uma exceção;

　　　　booleano isDone (): se as extremidades de execução de tarefas, cada extremidade ou cancelado durante normal ou anormal, return true;

　　　　boolean isCanceller (): Se a tarefa é concluída antes de ser cancelado, ele retorna true;

　　　　boolean cancelar (boolean mayInterrupRunning): Se o trabalho não foi iniciado, cancelar a execução método retorna false; se a tarefa já começou, será interrompido para executar esta tarefa cancelar fio método de uma maneira de tentar parar a execução da tarefa, se a parada for bem sucedida, return true;

　　　　Quando a tarefa foi iniciada, executar cancelar método (false) não terá efeito (rosca normal, para executar até a conclusão) para tarefas de execução fio, em seguida, retornar false;

　　　　Quando a tarefa foi iniciada, executar cancelar método retorna falso, MayInterruptRunning parâmetro indica se a interromper a execução de threads;

　　　　Na verdade Futuro fornece três funções:

　　　　　　1. Para a execução da tarefa de interrupção;

　　　　　　2. Determinar se a execução da tarefa é concluída;

　　　　　　3. Obter os resultados da execução da tarefa é concluída;

　　get obstrutiva () Método

público  classe FutureGet {
     pública  estáticos  vazios principais (String [] args) lança ExecutionException, InterruptedException {
        Executor ExecutorService = Executors.newFixedThreadPool (2 );
         // Criar um mobilizável, três segundos para retornar a String 
        uma mobilizável mobilizável = new new um mobilizável () {
            @Sobrepor
            pública chamada Object () lança Exceção {
                Thread.sleep ( 3000 );
                System.out.println ( "方法exigível执行!" );
                retornar "exigível" ;
            }
        };
        System.out.println ( "antes de enviar a tarefa:" + getStringDate ());
        Futuro futuro = executor.submit (exigível);
        System.out.println ( "Depois de fornecer missão antes de obter os resultados:" + getStringDate ());
        System.out.println ( "Get Valor de retorno:" + Future.get ());
        System.out.println ( "depois de adquirir os resultados:" + getStringDate ());
    }

    pública  estática Cordas getStringDate () {
        Ano data = new Date ();
        Formato SimpleDateFormat = new SimpleDateFormat ( "HH: mm: ss" );
        Corda dataString = format.format (data);
        voltar dataString;
    }
}

　　　　Você pode ver a partir da saída acima, após mobilização enviar para enviar a tarefa, poderia ter sido o segmento principal continua a correr para future.get () quando ele está bloqueado, espera até que a tarefa é concluída, obter o valor retornado, o segmento principal será continuar a executar;

　　Obstrutiva porque as chamadas de método get (), a tarefa não está terminado, ele irá esperar até que a tarefa é concluída, formando um bloqueio;

　　Tarefa quando você chamar o método começa a execução de apresentar, se quando você chamar o método get, a tarefa foi executada, então ele não irá causar obstrução;

　　Antes de chamar os seguintes métodos para dormir quatro segundos, desta vez valor pode retornar imediatamente:

　　enviar (tarefa Runnable)

　　　　Porque Runnable é nenhum valor de retorno, por isso, se você enviar uma palavras Execut�eis, ficar definitivamente obter o valor para o null;

público  classe SubmitRunnable {
     pública  estáticos  vazios principais (String [] args) lança ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool (2 );
        Executável Execut�el = novo Executel () {
            @Sobrepor
            pública  vazio run () {
                 tente {
                    Thread.sleep ( 2000 );
                    System.out.printlnl (Thread.currentThread () getNome ().);
                } Captura (InterruptedException e) {
                    e.printStackTrace ();
                }
            }
        };
        Futuro futuro = executor.submit (executável);
        System.out.println ( "valores de retorno:" + Future.get ());
    }
}

enviar (tarefa Runnable, resultado T)

　　Embora não Runnable passou diretamente para o conteúdo, mas pode passar através de um suporte enviar (tarefa Runnable, resultado T), esta transportadora adquire o valor de retorno;

público  classe de dados {
    String nome;
    sexo String;

    pública de Cordas getName () {
         return nome;
    }

    pública  vazio setName (String nome) {
         este .name = nome;
    }

    pública de Cordas getSex () {
         return sexo;
    }

    pública  vazio setSex (sexo String) {
         este .sex = sexo;
    }
}

　　Runnable passou no construtor:

público  classe MyThreadData implementos Runnable {
    Ano data;

    pública MyThreadData (dados de Dados) {
         este .data = dados;
    }

    @Sobrepor
    pública  vazio run () {
         tente {
            Thread.sleep ( 2000 );
            System.out.println ( "execução tópico:" );
            data.setName ( "Joe Smith" );
            data.setSex ( "女" );
        } Captura (InterruptedException e) {
            e.printStackTrace ();
        }
    }
    público  estático  vazio main (String [] arg) lança ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool (2 );
        Dados de dados = novos dados ();
        Futuro <Data> submit = executor.submit ( novo MyThreadData (dados), dados);
        System.out.println ( "返回结果:" + submit.get () getName (+) "o sexo:". + . Submit.get () getSex ());
    }
}

　　get (longa var1, TimeUnit var3)

público  classe GetTime {
     pública  estáticos  vazios principais (String [] args) lança ExecutionException, InterruptedException, TimeoutException {
        Executor ExecutorService = Executors.newFixedThreadPool (2 );
         // Criar um mobilizável, três segundos para retornar a String 
        uma mobilizável mobilizável = new new um mobilizável () {
            @Sobrepor
            pública chamada Object () lança Exceção {
                Thread.sleep ( 3000 );
                System.out.println ( "方法exigível执行!" );
                retornar "exigível" ;
            }
        };
        System.out.println ( "antes de enviar a tarefa:" + getStringDate ());
        Futuro futuro = executor.submit (exigível);
        System.out.println ( "Depois de fornecer missão antes de obter os resultados:" + getStringDate ());
        System.out.println ( "Get Valor de retorno:" + Future.get (2 , TimeUnit.SECONDS));
        System.out.println ( "depois de adquirir os resultados:" + getStringDate ());
    }

    pública  estática Cordas getStringDate () {
        Ano data = new Date ();
        Formato SimpleDateFormat = new SimpleDateFormat ( "HH: mm: ss" );
        Corda dataString = format.format (data);
        voltar dataString;
    }
}