Cómo devolver el objeto de Callable()

Question

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

//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

Answer 1

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)); 
     } 
    } 

Answer 2

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.

Answer 3

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().