Comment retourner un objet Appelable()

Je suis en train de retourner un tableau 2d de call(), je vais avoir quelques problèmes. Mon code pour l'instant est:

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

Ce code compile, ce n'est pas le retour de mon tableau. Je suis sûr que je suis probablement l'utilisation de la mauvaise syntaxe, mais je ne trouve pas de bons exemples.

EDIT: changé un peu

Quel est-il de retour? Où est la longueur en venir? Où sont Matrice1 et Matrice2 en venir?
Je suis sûr que answer = multiplyArray(Array1, Array2, length,); ne compile pas car il ya un supplément de ,. Vous devriez poster plus de Code, parce que je ne pense pas que c'est possible de faire une hypothèse ici sans doute.
Qu'est-ce que l'invocation de la méthode call ()?

OriginalL'auteur user650309 | 2011-04-01

  1. 5

    Ajoutant à Joseph Ottinger réponse, pour transmettre des valeurs à être utilisés à l'intérieur de Appelable de la méthode call (), vous pouvez utiliser des bouchons:

        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));
        }
    }
    Je dois dire un grand merci à Joseph Ottinger et Marimuthu Madasamy. Je suis arrivé à la fin, avec votre aide.

    OriginalL'auteur Marimuthu Madasamy

  2. 9

    Voici un peu de code illustrant l'utilisation de la "Callable" <> interface:

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

    Ce que cela fait, c'est de construire un objet qui peut être soumis à un exécuteur testamentaire service. C'est fondamentalement la même que sur un Praticable, sauf qu'il peut renvoyer une valeur, ce que nous faisons ici est la création d'un ExecutorService avec deux threads, puis en soumettant ce exigible pour le service.

    La prochaine chose qui se passe est le résultat.get(), qui permet de bloquer jusqu'à ce que le callable retourne.

    Vous ne devriez probablement pas faire le Thread de gestion de vous-même.

    C'est très utile, mais comment est-il possible d'envoyer des objets à l'objet appelable? J'ai besoin d'envoyer deux tableaux.
    Vous pourriez transmettre à la construction, ou d'étendre le Callable interface à utiliser une instance locale de tableaux.
    Super réponse, et bravo pour la promotion de la ExecutorService d'utilisation. Il n'y a pas beaucoup d'endroits on doit être à l'aide de Fil à jamais.

    OriginalL'auteur Joseph Ottinger

  3. 2

    En plus de Joseph excellente réponse, notez que votre signature de la méthode est int[][] call(int[][]). Si vous faites référence à la Callable javadoc, vous verrez que le Callable's call() méthode ne prend pas d'argument. Si votre méthode est une surcharge, pas un remplacement, et donc de ne pas être appelé par tout ce qui est appel Callable's call() méthode.

    heh, je vous remercie. J'ai pensé qu'il était plus facile de montrer l'utilisation correcte plutôt que d'essayer de comprendre qu'est ce qui se passe réellement dans le (légèrement incomplète) exemple de code.
    Comme les Allemands disent: "Da liegt der Hund begraben" - c'est là que réside le problème.

    OriginalL'auteur QuantumMechanic