1. package com.company;
2.  
3. import com.sun.org.apache.xpath.internal.operations.Div;
4.  
5. import java.util.Random;
6. import java.util.concurrent.ForkJoinPool;
7. import java.util.concurrent.RecursiveTask;
8.  
9. class DivideTask extends RecursiveTask<int[]> {
10.  
11.     int[] arrayToDivide;
12.  
13.     final private int TRESHHOLD =100;
14.  
15.     public DivideTask(int[] arrayToDivide) {
16.         this.arrayToDivide = arrayToDivide;
17.     }
18.  
19.     protected int[] compute() {
20.  
21.         if(arrayToDivide.length>1) {
22.             int[] array_left = new int[arrayToDivide.length / 2];
23.             int[] array_right = new int[arrayToDivide.length - array_left.length];
24.  
25.             System.arraycopy(arrayToDivide, 0, array_left, 0, array_left.length);
26.             System.arraycopy(arrayToDivide, array_left.length, array_right, 0, array_right.length);
27.  
28.             DivideTask task1 = new DivideTask(array_left);
29.             DivideTask task2 = new DivideTask(array_right);
30.  
31.             task1.fork();
32.             task2.fork();
33.  
34.             //Wait for results from both tasks
35.             int[] tab1 = task1.join();
36.             int[] tab2 = task2.join();
37.             int[] scal_tab = new int[tab1.length + tab2.length];
38.  
39.             scal_tab(tab1, tab2, scal_tab);
40.  
41.             return scal_tab;
42.         }
43.         return arrayToDivide;
44.     }
45.  
46.     private void scal_tab(
47.             int[] tab1,
48.             int[] tab2,
49.             int[] scal_tab) {
50.  
51.         int i = 0, j = 0, k = 0;
52.  
53.         while ((i < tab1.length) && (j < tab2.length)) {
54.  
55.             if (tab1[i] < tab2[j]) {
56.                 scal_tab[k] = tab1[i++];
57.             } else {
58.                 scal_tab[k] = tab2[j++];
59.             }
60.  
61.             k++;
62.         }
63.  
64.         if (i == tab1.length) {
65.  
66.             for (int a = j; a < tab2.length; a++) {
67.                 scal_tab[k++] = tab2[a];
68.             }
69.  
70.         } else {
71.  
72.             for (int a = i; a < tab1.length; a++) {
73.                 scal_tab[k++] = tab1[a];
74.             }
75.  
76.         }
77.     }
78.  
79.     public static void main(String[] args){
80.         int[] tab = randomTab();
81.  
82.         System.out.println("PRZED SORTOWANIEM:\n");
83.         printTab(tab);
84.  
85.         DivideTask task = new DivideTask(tab);
86.         ForkJoinPool forkJoinPool = new ForkJoinPool();
87.         forkJoinPool.invoke(task);
88.         int[] tab2 = task.join();
89.         System.out.println("PO SORTOWANIU:\n");
90.         printTab(tab2);
91.  
92.     }
93.  
94.     public static int[] randomTab(){
95.         Random random = new Random();
96.         int[] tab = new int[20];
97.         for(int i =0;i<20;i++){
98.             tab[i] = random.nextInt(1000);
99.         }
100.         return tab;
101.     }
102.  
103.     public static void printTab(int[] tab){
104.         for(int i=0;i<tab.length;++i){
105.             System.out.print(tab[i]+" ");
106.         }
107.         System.out.println();
108.     }
109. }
110.