2011-04-01 23 views
7

Estoy tratando de devolver una matriz 2d de call(), tengo algunos problemas. Mi código hasta ahora es:Cómo devolver el objeto de Callable()

//this is the end of main 
Thread t1 = new Thread(new ArrayMultiplication(Array1, Array2, length)); 
t1.start(); 
} 

    public int[][] call(int[][] answer) 
    {  

    int[][] answer = new int[length][length]; 

    answer = multiplyArray(Array1, Array2, length); //off to another function which returns the answer to here 

    return answer;         
    } 

Este código se compila, esto no devuelve mi matriz. Estoy seguro de que probablemente estoy usando la sintaxis incorrecta, pero no puedo encontrar ningún buen ejemplo.

EDIT: cambió un poco

+0

Lo que se lo va a devolver? ¿De dónde viene la longitud? ¿De dónde vienen Array1 y Array2? –

+0

Estoy bastante seguro de que 'answer = multiplyArray (Array1, Array2, length,);' no se compilará ya que hay un ',' extra. Debería publicar más código, porque no creo que sea posible hacer una suposición aquí sin adivinar. –

+0

¿Qué está invocando el método call()? – dontocsata

Respuesta

5

Agregando a la respuesta de José Ottinger, para pasar valores a ser utilizados en el interior la llamada de método que se puede llamar(), puede utilizar cierres:

public static Callable<Integer[][]> getMultiplierCallable(final int[][] xs, 
      final int[][] ys, final int length) { 
     return new Callable<Integer[][]>() { 
      public Integer[][] call() throws Exception { 
       Integer[][] answer = new Integer[length][length]; 
       answer = multiplyArray(xs, ys, length); 
       return answer; 
      } 
     }; 
    } 

    public static void main(final String[] args) throws ExecutionException, 
      InterruptedException { 
     final int[][] xs = {{1, 2}, {3, 4}}; 
     final int[][] ys = {{1, 2}, {3, 4}}; 
     final Callable<Integer[][]> callable = getMultiplierCallable(xs, ys, 2); 
     final ExecutorService service = Executors.newFixedThreadPool(2); 
     final Future<Integer[][]> result = service.submit(callable); 
     final Integer[][] intArray = result.get(); 
     for (final Integer[] element : intArray) { 
      System.out.println(Arrays.toString(element)); 
     } 
    } 
+0

Tengo que agradecer a Joseph Ottinger y Marimuthu Madasamy. Llegué al final con tu ayuda. – user650309

9

Aquí hay algo de código que muestra el uso de la Callable <> Interfaz:

public class test { 
public static void main(String[] args) throws ExecutionException, InterruptedException { 
    Callable callable = new Callable() { 
     @Override 
     public int[][] call() throws Exception { 
      int[][] array = new int[5][]; 
      for (int i = 0; i < array.length; i++) { 
       array[i] = new int[]{5 * i, 5 * i + 1, 5 * i + 2, 5 * i + 3}; 
      } 

      return array; 
     } 
    }; 

    ExecutorService service = Executors.newFixedThreadPool(2); 
    Future<int[][]> result = service.submit(callable); 

    int[][] intArray = result.get(); 
    for (int i = 0; i < intArray.length; i++) { 
     System.out.println(Arrays.toString(intArray[i])); 
    } 
} 
} 

Lo que esto hace es construir un objeto que puede ser sometida a un servicio de ejecutor. Es fundamentalmente lo mismo que Runnable, excepto que puede devolver un valor; lo que estamos haciendo aquí es crear un ExecutorService con dos subprocesos, y luego enviarlo al servicio.

Lo siguiente que sucede es result.get(), que bloqueará hasta que se vuelva a llamar.

Probablemente no deba hacer la gestión de subprocesos usted mismo.

+0

Esto es muy útil, pero ¿cómo es posible enviar objetos al objeto invocable? Necesito enviar dos arreglos. – user650309

+0

Puede pasarlos en la construcción o extender la interfaz de llamadas para usar matrices locales de instancias. –

+0

Excelente respuesta y felicitaciones por promover el uso de ExecutorService. Realmente no hay muchos lugares donde uno deba usar Thread nunca más. –

2

Además de la excelente respuesta de Joseph, tenga en cuenta que la firma de su método es int[][] call(int[][]). Si hace referencia al Callable javadoc, verá que el método Callablecall() no toma ningún argumento. Por lo tanto, su método es una sobrecarga, no una anulación, por lo que no será invocado por ningún método que llame al Callablecall().

+0

je, gracias. Pensé que era más fácil mostrar el uso correcto en lugar de tratar de descubrir qué estaba sucediendo realmente en el código de ejemplo (ligeramente incompleto). –

+0

Como dicen los alemanes: "Da liegt der Hund begraben" - aquí es donde radica el problema. –

Cuestiones relacionadas