जावा कंजिरेन्सी - फोर्क-जॉइन फ्रेमवर्क

कांटा-जुड़ने की रूपरेखा कई श्रमिकों पर एक निश्चित कार्य को तोड़ने की अनुमति देती है और फिर उन्हें संयोजित करने के लिए परिणाम की प्रतीक्षा करती है। यह मल्टी-प्रोसेसर मशीन की क्षमता का काफी हद तक लाभ उठाता है। निम्नलिखित मूल अवधारणाएं और कांटे-जुड़ने की रूपरेखा में उपयोग की जाने वाली वस्तुएं हैं।

कांटा

कांटा एक ऐसी प्रक्रिया है जिसमें एक कार्य खुद को छोटे और स्वतंत्र उप-कार्यों में विभाजित करता है जिसे समवर्ती रूप से निष्पादित किया जा सकता है।

वाक्य - विन्यास

Sum left  = new Sum(array, low, mid);
left.fork();

यहाँ Sum, RecursiveTask और left.fork का उपवर्ग है () कार्य को उप-कार्यों में बदल देता है।

शामिल हों

ज्वाइन एक ऐसी प्रक्रिया है जिसमें एक कार्य उप-कार्यों के सभी परिणामों में शामिल हो जाता है, जब उप-कार्य निष्पादन समाप्त हो जाता है, अन्यथा यह प्रतीक्षा करता रहता है।

वाक्य - विन्यास

left.join();

यहां बाईं ओर सम क्लास का एक ऑब्जेक्ट है।

ForkJoinPool

यह एक विशेष थ्रेड पूल है जिसे फोर्क-एंड-जॉइन कार्य विभाजन के साथ काम करने के लिए डिज़ाइन किया गया है।

वाक्य - विन्यास

ForkJoinPool forkJoinPool = new ForkJoinPool(4);

यहां 4 सीपीयू के समानांतरवाद स्तर के साथ एक नया फोर्कजॉइनपूल।

RecursiveAction

RecursiveAction किसी कार्य का प्रतिनिधित्व करता है जो किसी भी मूल्य को वापस नहीं करता है।

वाक्य - विन्यास

class Writer extends RecursiveAction {
   @Override
   protected void compute() { }
}

RecursiveTask

RecursiveTask एक कार्य का प्रतिनिधित्व करता है जो एक मूल्य देता है।

वाक्य - विन्यास

class Sum extends RecursiveTask<Long> {
   @Override
   protected Long compute() { return null; }
}

उदाहरण

निम्न TestThread प्रोग्राम थ्रेड-आधारित वातावरण में Fork-Join ढांचे का उपयोग दिखाता है।

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException, 
      ExecutionException {
      
      int nThreads = Runtime.getRuntime().availableProcessors();
      System.out.println(nThreads);
      
      int[] numbers = new int[1000]; 

      for(int i = 0; i < numbers.length; i++) {
         numbers[i] = i;
      }

      ForkJoinPool forkJoinPool = new ForkJoinPool(nThreads);
      Long result = forkJoinPool.invoke(new Sum(numbers,0,numbers.length));
      System.out.println(result);
   }  

   static class Sum extends RecursiveTask<Long> {
      int low;
      int high;
      int[] array;

      Sum(int[] array, int low, int high) {
         this.array = array;
         this.low   = low;
         this.high  = high;
      }

      protected Long compute() {
         
         if(high - low <= 10) {
            long sum = 0;
            
            for(int i = low; i < high; ++i) 
               sum += array[i];
               return sum;
         } else {	    	
            int mid = low + (high - low) / 2;
            Sum left  = new Sum(array, low, mid);
            Sum right = new Sum(array, mid, high);
            left.fork();
            long rightResult = right.compute();
            long leftResult  = left.join();
            return leftResult + rightResult;
         }
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा।

उत्पादन

32
499500