Параллельно в Java 7 с результатом, используя неконечное переменные

Question

У меня есть что-то вроде:

int [] array1 = new int[20]; 
int [] array2 = new int[20]; 
int total= 0; 
Random generator = new Random(); 

for(int i = 0; i < 10000; i++){ 
    int tmp = generator.nextInt(20); 
    boolean win = custom_function(...); 
    array1[tmp]++; 
    array2[tmp]++ 
    total++; 
} 

// do something with the arrays 

И я не знаю, как реализовать его параллельно! При использовании конструкции, как

ExecutorService exec = 
    Executors.newFixedThreadPool(SOME_NUM_OF_THREADS); 
try { 
    for (final Object o : list) { 
     exec.submit(new Runnable() { 
      @Override 
      public void run() { 
       // do stuff with o. 
      } 
     }); 
    } 
} finally { 
    exec.shutdown(); 
} 

Я просто не возвращения ничего или изменить что-либо, потому что он работает только с конечными переменными может! Как действовать?

---

Каждый работоспособным должен изменить переменные array1[tmp], array2[tmp] и array3[tmp]. Обратите внимание, что это может быть сделано через какое-то соединение вилки, я просто не знаю, как это сделать.

Answer 1

Кажется, что вы действительно хотите Callable, который вычисляет результат, а не Runnable.

submit(Callable) возвращает Future, на который вы можете позвонить get и получить результат.

import java.util.*; 
import java.util.concurrent.*; 

class Example { 
    public static void main(String[] args) { 
     final int n = 3; 
     final int length = 20; 

     ExecutorService ex = Executors.newFixedThreadPool(n); 
     List<Future<int[]>> futures = new ArrayList<>(); 

     for (int i = 0; i < n; ++i) { 
      futures.add(ex.submit(new Callable<int[]>() { 
       Random r = new Random(); 

       @Override 
       public int[] call() { 
        int[] result = new int[length]; 

        for (int i = 0; i < length; ++i) { 
         int tmp = r.nextInt(length); 
         result[tmp]++; 
        } 

        return result; 
       } 
      })); 
     } 

     ex.shutdown(); 

     for (Future<int[]> f : futures) { 
      try { 
       System.out.println(Arrays.toString(f.get())); 
      } catch (InterruptedException|ExecutionException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Пример вывода:

[0, 1, 1, 1, 0, 1, 0, 2, 3, 1, 2, 0, 1, 2, 0, 2, 1, 2, 0, 0] 
[2, 2, 1, 0, 0, 2, 1, 1, 3, 1, 2, 1, 0, 0, 1, 1, 0, 1, 1, 0] 
[0, 1, 1, 1, 0, 1, 0, 4, 1, 2, 0, 1, 0, 1, 2, 2, 1, 0, 0, 2]