Fork/Join framework has been introduced in java 7 to solve multi-threading/parallel programming issues.
It is very difficult to deal with concurrent (parallel) programming by using traditional way. Because you have to deal with thread synchronization, notification, შეუერთდეს და ა.შ. და ასევე პრობლემების საერთო რესურსების,,en,ენის დონის მხარდაჭერით კონკურენტმა პროგრამირების ჯავის პლატფორმა არის ძალიან ძლიერი, როგორც დასტურდება ძალისხმევით სხვადასხვა თემებში,,en,ამ თემებში, ყველა ცდილობდა, რათა ამომწურავი პროგრამირების მოდელები და ეფექტური შესრულება რომ რეფერატები ტკივილი რაოდენობა დაკავშირებულია მრავალ ნაკადიან და გავრცელება applications.Java პლატფორმა,,en,სტანდარტული გამოცემა,,en,Java SE,,es,და შემდეგ Java SE,,en,გააცნო კომპლექტი პაკეტები,,en,შემსრულებელი მომსახურება,,en,უზრუნველყოფს ძლიერი concurrency სამშენებლო ბლოკები,,en,კიდევ უფრო გაძლიერდება ფარგლებში დასძინა მეტი მხარს უჭერს პარალელიზმი,,en,Fork / გაწევრიანება არის ახალი კონცეფციის java,,en,ძირითადი მიზანი ამ ფარგლებში, ხელი შეუწყოს multithreading გარემოს Java პროგრამები,,en,ჯარიმა შემდეგ შემსრულებელს მომსახურება ჩარჩო fork / შეუერთდეს ფარგლებში,,en. language-level support for concurrent programming on the Java platform is very strong as proven by the efforts in different communities. These communities all tried to provide comprehensive programming models and efficient implementations that abstracts the pain points associated with multi-threaded and distributed applications.Java Platform, Standard Edition (Java SE) 5 and then Java SE 6 introduced a set of packages (Executor service)providing powerful concurrency building blocks. Java SE 7 further enhanced the framework adding more supports for parallelism.
Fork/Join is a new concept in java 7.0 version. The basic purpose of this framework is to facilitate the multithreading environment in java applications. The finer then the executor service framework is fork/join framework. იგი იღებს უპირატესობა ყველა გადამუშავების ძალა და აქედან გამომდინარე, პროგრამა იღებს უფრო რესურსი და დამუშავება ძალა,,en,ეს არის განხორციელება ExecutorService ინტერფეისი, რომელიც დაგეხმარებათ ისარგებლოს მრავალჯერადი პროცესორები,,en,იგი განკუთვნილია სამუშაოები, რომელიც შეიძლება დაყოფილი პატარა დარტყმები რეკურსიული და აქედან გამომდინარე, მიიღოს დამუშავება სწრაფად,,en,მსგავსი ExecutorService,,en,ჩანგალი / შეუერთდეს ფარგლებში ასევე ავრცელებს ამოცანები თანამშრომელი თემა ნაკადი აუზი,,en,მაგრამ მთავარი განსხვავება ისაა, რომ fork / შეუერთდეს ფარგლებში იყენებს სამუშაო ქურდობაში ალგორითმი,,en,აქ თანამშრომელი თემა, რომ ამოიწურა რამ უნდა გააკეთოს შეიძლება მოიპარონ ამოცანები სხვა თემა, რომელიც ჯერ კიდევ დაკავებული,,en,ForkJoinPoolclass გაგრძელების AbstractExecutorService და გულში ფარგლებში,,en. It is an implementation of the ExecutorService interface that helps you take advantage of multiple processors. It is designed for works which can be broken into smaller pieces recursively and hence make the processing faster.
Similar to ExecutorService, the fork/join framework also distributes tasks to worker threads in a thread pool. But the main difference is that the fork/join framework uses a work-stealing algorithm. Here the worker threads that run out of things to do can steal tasks from other threads that are still busy. The ForkJoinPoolclass is an extension of AbstractExecutorService and the heart of the framework. ForkJoinPool ახორციელებს ძირითადი სამუშაო ქურდობაში ალგორითმი და ახორციელებს ForkJoinTasks,,en,ახლა ნება მომეცით მიიღოს მაგალითად უნდა გვესმოდეს, რომ კონცეფციის დეტალები,,en,ძირითადი ნაბიჯები,,en,გაყოფილი ამოცანა,,en,მივანიჭოთ მას შესაძლო თემა,,en,დასრულების შემდეგ შეუერთდება მოცულობით და რათა ის დაასრულებს,,en,მოდით სია, რომელიც შეიცავს დიდი რაოდენობით რიცხვებით გენერირდება შემთხვევითი,,en,ეს კლასი გვიჩვენებს ტრადიციული გზა უნდა გააკეთოს ამოცანა,,en,ახლა შემდეგი SplitTask კლასის ასრულებენ გაყოფილი და შეუერთდეს ამოცანა,,en,დაცული ბათილად compute,,en,list.length ==,,en,შედეგი = list,,en,int შუაში = list.length,,en,L1 = Arrays.copyOfRange,,en,სია,,en,შუაში,,en,l2 = Arrays.copyOfRange,,ar,list.length,,en,SplitTask s1 = new SplitTask,,en,L1,,st,SplitTask s2 = new SplitTask,,en,l2,,ar,forkJoin,,no,s2,,ja,შედეგი = s1.result,,en,s2.result,,en,ბოლო კლასის ტესტირების პროცესი,,en.
Now let me take an example to understand the concept in details.
The basic steps are
· Split the task
· Assign it to the available threads
· After completion join the chunks and make it complete
Let us take a list which will contain large number of integers generated at random.
This class is showing the traditional way to do the task.
package javablog.levent.com;
import java.util.Random;
// This class defins a list which will contain large number of integers.
public class LargeInteger {
private final int[] list = new int[2000000];
public largeInteger() {
Random generator = new Random(19580427);
for (int i = 0; i < list.length; i++) {
list[i] = generator.nextInt(500000);
}
}
public int[] getList() {
return list;
}
}
Now the following SplitTask class is performing the split and join task.
package javablog.levent.com;
import java.util.Arrays;
import jsr166y.forkjoin.RecursiveAction;
public class SplitTask extends RecursiveAction {
private int[] list;
public long result;
public SplitTask(int[] array) {
this.list = array;
}
@ Override
protected void compute() {
თუ (list.length == 1) {
result = list[0];
} სხვა {
int midpoint = list.length / 2;
int[] l1 = Arrays.copyOfRange(list, 0, midpoint);
int[] l2 = Arrays.copyOfRange(list, midpoint, list.length);
SplitTask s1 = new SplitTask(l1);
SplitTask s2 = new SplitTask(l2);
forkJoin(s1, s2);
result = s1.result + s2.result;
}
}
}
The last class is testing the process. ეს არის არა მარტო აპელირებს ForkJoinExecutor აუზი შეასრულოს დავალება,,en,Fork / გაწევრიანება ფარგლებში,,en.
package javablog.levent.com;
import jsr166y.forkjoin.ForkJoinExecutor;
import jsr166y.forkjoin.ForkJoinPool;
import javablog.levent.com.SplitTask;
public class TestForkJoin {
public static void main(String[] args) {
LargeInteger test = new LargeInteger();
// Check the number of available processors
int nThreads = Runtime.getRuntime().availableProcessors();
System.out.println(nThreads);
SplitTask mfj = new SplitTask(test.getList());
ForkJoinExecutor pool = new ForkJoinPool(nThreads);
pool.invoke(mfj);
long result = mfj.getResult();
System.out.println("Done. Result: " + result);
}
}
