Java Language
Parallell programmering med Fork / Join-ramverket

Fork / Gå med uppgifter i Java

Ramen för gaffel / koppling i Java är idealisk för ett problem som kan delas upp i mindre bitar och lösas parallellt. De grundläggande stegen för ett gaffel / kopplingsproblem är:

• Dela upp problemet i flera delar
• Lös var och en av bitarna parallellt med varandra
• Kombinera var och en av dellösningarna till en helhetslösning

En ForkJoinTask är gränssnittet som definierar ett sådant problem. Det förväntas vanligtvis att du underklasserar en av dess abstrakta implementationer (vanligtvis RecursiveTask ) snarare än att implementera gränssnittet direkt.

I det här exemplet kommer vi att sammanfatta en samling heltal och dela tills vi kommer till batchstorlekar på högst tio.

import java.util.List;
import java.util.concurrent.RecursiveTask;

public class SummingTask extends RecursiveTask<Integer> {
    private static final int MAX_BATCH_SIZE = 10;

    private final List<Integer> numbers;
    private final int minInclusive, maxExclusive;

    public SummingTask(List<Integer> numbers) {
        this(numbers, 0, numbers.size());
    }

    // This constructor is only used internally as part of the dividing process
    private SummingTask(List<Integer> numbers, int minInclusive, int maxExclusive) {
        this.numbers = numbers;
        this.minInclusive = minInclusive;
        this.maxExclusive = maxExclusive;
    }

    @Override
    public Integer compute() {
        if (maxExclusive - minInclusive > MAX_BATCH_SIZE) {
            // This is too big for a single batch, so we shall divide into two tasks
            int mid = (minInclusive + maxExclusive) / 2;
            SummingTask leftTask = new SummingTask(numbers, minInclusive, mid);
            SummingTask rightTask = new SummingTask(numbers, mid, maxExclusive);

            // Submit the left hand task as a new task to the same ForkJoinPool
            leftTask.fork();

            // Run the right hand task on the same thread and get the result
            int rightResult = rightTask.compute();

            // Wait for the left hand task to complete and get its result
            int leftResult = leftTask.join();

            // And combine the result
            return leftResult + rightResult;
        } else {
            // This is fine for a single batch, so we will run it here and now
            int sum = 0;
            for (int i = minInclusive; i < maxExclusive; i++) {
                sum += numbers.get(i);
            }
            return sum;
        }
    }
}

En instans av denna uppgift kan nu skickas till en instans av ForkJoinPool .

// Because I am not specifying the number of threads
// it will create a thread for each available processor
ForkJoinPool pool = new ForkJoinPool();

// Submit the task to the pool, and get what is effectively the Future
ForkJoinTask<Integer> task = pool.submit(new SummingTask(numbers));

// Wait for the result
int result = task.join();