"Turn" mobilizável e Futuro

Por mobilizável?

Existem duas maneiras de criar tópicos, um é estendendo a classe Thread, eo outro é através do uso de Runnable criar tópicos.

No entanto, Runnable faltando um recurso que, quando o termina rosca (ie run () para completa), não podemos fazer os resultados de retorno fio. Para suportar essa funcionalidade, Java fornece uma interface Callable.

Mobilizável vs Runnable

RUNNABLE alcançar retornos necessidade nada para implementar o método run (), e por um mobilizável, necessidade de implementar o método de chamada () retorna os resultados após a conclusão. Por favor note que você não pode usar mobilizável criar um thread, a thread só pode ser usado para criar Runnable.
- Por que não criar um segmento envolve ExecutorService o método de envio
Outra diferença é o método call () pode lançar uma exceção, e o run () não pode.
Este é um código mobilizável exemplo, neste exemplo cerca de 0 - Retorna um atraso aleatório de 4 segundos.

// Java program to illustrate Callable 
// to return a random number 
import java.util.Random; 
import java.util.concurrent.Callable; 
import java.util.concurrent.FutureTask; 

class CallableExample implements Callable 
{ 

    public Object call() throws Exception 
    { 
        // Create random number generator 
        Random generator = new Random(); 

        Integer randomNumber = generator.nextInt(5); 

        // To simulate a heavy computation, 
        // we delay the thread for some random time 
        Thread.sleep(randomNumber * 1000); 

        return randomNumber; 
    } 
}

Futuro

Quando o método call () é concluída, a resposta deve ser armazenado no objeto principal fio conhecida, então você sabe que o principal segmento do segmento é retornado.

O programa irá depois ser armazenadas e como obter esse resultado?

Para fazer isso, você pode usar o objeto futuro. Os resultados futuros serão armazenados como um objeto - pode guardar temporariamente os resultados, mas no futuro será salvo (uma vez retorno mobilizável). Portanto, Futuro é basicamente o segmento principal pode acompanhar o progresso e os resultados de uma forma que outras threads. Para implementar essa interface deve ser reescrito cinco métodos, mas devido ao seguinte exemplo usa uma implementação específica da biblioteca, de modo que este método só lista importante.

Na verdade, mobilizável e Futuro fazer duas coisas

Mobilizável e Runnable semelhante, porque ele encapsula a tarefa seja executada em um segmento diferente
Futuro usado para armazenar os resultados obtidos a partir de outro segmento.

Os método precisa ser reescrito

public boolean cancel (boolean mayInterrup): Para parar a tarefa. Se você ainda não começou, ele irá parar a tarefa. Se você tiver começado, você só vai interrupção tarefa quando mayInterrupt é verdade.
public Object get() throws InterruptedException，ExecutionException: Para obter os resultados da tarefa. Se a tarefa for concluída, ele retorna o resultado imediatamente, caso contrário ele irá esperar para que a tarefa completa, e retorna o resultado.
public boolean isDone(): Se a tarefa for concluída, ele retorna true, false caso contrário

Para criar um segmento, você precisa de interface Runnable. A fim de obter os resultados, precisamos classe Futuro.

biblioteca Java tem um tipo específico de um FutureTask, os implementos do tipo Executï¿½eis e futuras e facilmente combinar as duas funções.

FutureTask pode ser criado através do fornecimento mobilizável seu construtor. Em seguida, o objeto é fornecido ao construtor Tópico FutureTask para criar um objeto Thread.

Mais uma vez, não pode ser usado diretamente mobilizável criar tópicos.

Esta é a completa utilização de código de exemplo a mobilizável e FutureTask.

// Java program to illustrate Callable and FutureTask 
// for random number generation 

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class CallableExample implements Callable {

    public Object call() throws Exception {
        Random generator = new Random();
        Integer randomNumber = generator.nextInt(5);

        Thread.sleep(randomNumber * 1000);

        return randomNumber;
    }

}

public class CallableFutureTest {
    public static void main(String[] args) throws Exception {

        // FutureTask implements both Runnable and Future 
        FutureTask[] randomNumberTasks = new FutureTask[5];

        for (int i = 0; i < 5; i++) {
            Callable callable = new CallableExample();

            // 用 Callable 创建 FutureTask
            randomNumberTasks[i] = new FutureTask(callable);

            // 在实现Runnable时，使用FutureTask创建线程
            Thread t = new Thread(randomNumberTasks[i]);
            t.start();
        }

        for (int i = 0; i < 5; i++) {
            //  Future, we can call get() 
            System.out.println(randomNumberTasks[i].get());
            // 该方法将阻塞直到获得结果。
            // get方法可以引发检查异常，例如被中断时。 这就是将throws子句添加到main的原因
        }
    }
}