Java：仅限于方法的线程之间的通信

Question

I have to create a method to calculate the sum of all elements in an array. The caveat is that the array is divided into a number of parts for many threads to calculate these parts simultaneously, and then combine to calculate the sum

All of these are restricted to inside the method code. The problem is when I write:

Thread t = new Thread(()->{
                int sum=0;
                //do some calculations
                //time to pass this result back to the main method
            });

The local anonymous class can only access final or effectively final local variable of the main method, which means I can't create a local variable and then change it to update the result. I can't think of a way to pass a thread's result back to combine with the results from the other threads.

Is there any way to solve this?

Answer 1

You can divide up the work in your main thread and do something like this:

 public class Foo implements Runnable {
     private volatile CustomArray<Integer> arr;
     private volatile Integer sum;

     public Foo(CustomArray<Integer> arr) {
         this.arr = arr;
     }

     @Override
     public void run() {
        synchronized(this.arr) {
            sum = arr.getSum();
        }
     }

     public Integer getValue() {
         synchronized(this.arr) {
             return sum;
         }
     }
 }

And call from another thread like so:

CustomArray<Integer> completeArray = new CustomArray<>(data);
ArrayList<CustomArray<Integer>> dividedArrays = completeArray.divideWork();

for(CustomArray<Integer> each : dividedArrays) {
    Foo foo = new Foo(each);
    new Thread(foo).start();

    // ... join through some method

    Integer value = foo.getValue();
}

Or, you can use an Executor and a Callable :

public void test() throws InterruptedException, ExecutionException
    {   
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() {
                return 2;
            }
        };
        Future<Integer> future = executor.submit(callable);

        // returns 2 or raises an exception if the thread dies
        Integer output = future.get();

        executor.shutdown();
    }