Java Language
फोर्क / जॉइन फ्रेमवर्क के साथ समानांतर प्रोग्रामिंग

जावा में फोर्क / जॉइन टास्क

जावा में कांटा / जुड़ाव एक ऐसी समस्या के लिए आदर्श है जिसे छोटे टुकड़ों में विभाजित किया जा सकता है और समानांतर में हल किया जा सकता है। एक कांटा / जुड़ने की समस्या के मूलभूत चरण हैं:

• समस्या को कई टुकड़ों में विभाजित करें
• प्रत्येक टुकड़े को एक दूसरे के समानांतर हल करें
• सभी उप-समाधानों को एक समग्र समाधान में मिलाएं

एक ForkJoinTask इंटरफ़ेस है जो इस तरह की समस्या को परिभाषित करता है। आमतौर पर यह उम्मीद की जाती है कि आप सीधे इंटरफ़ेस को लागू करने के बजाय इसके अमूर्त कार्यान्वयन (आमतौर पर RecursiveTask ) में से एक को उपवर्गित करेंगे।

इस उदाहरण में, हम पूर्णांकों के एक संग्रह को विभाजित करने जा रहे हैं, जब तक कि हम दस से अधिक नहीं के बैच आकारों तक प्राप्त न कर लें।

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

इस कार्य का एक उदाहरण अब 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();