The problem lies here:
Integer[] data = new Integer[size];
int[] temp = new int[size];
int[] temp2 = new int[size];

It should be:
Integer[] data = new Integer[size];
Integer[] temp = new Integer[size];
Integer[] temp2 = new Integer[size];

You’re comparing an array of objects to an array of ints. Java operates faster on primitive types.

Also, when benchmarking it’s a good idea to take the average of several runs.

import java.util.Arrays;

import jsr166y.*;
import extra166y.*;

public class TestParallelArray {
public static void main(String[] args) {

int size = 15000000;
Integer[] data = new Integer[size];
int[] temp = new int[size];
int[] temp2 = new int[size];

for (int i = 0; i < size; i++) {
data[i] = new Integer((int)(Math.random()*10000000));
temp[i] = data[i];
temp2[i] = data[i];
}

ForkJoinPool forkJoinPool = new ForkJoinPool();
ParallelArray parallelArray = ParallelArray.createFromCopy(data, forkJoinPool);

TestParallelArray testParallelArray = new TestParallelArray();

System.out.println(“Sorting now”);
long start = System.currentTimeMillis();
testParallelArray.shuttleSort(temp2, temp, 0, size);
long finish = System.currentTimeMillis();
System.out.println(“Time taken = ” + (finish – start) + ” milliseconds (Using sequential)”);

start = System.currentTimeMillis();
forkJoinPool.invoke(testParallelArray.new SortTask(temp2, temp, 0, size));
finish = System.currentTimeMillis();
System.out.println(“Time taken = ” + (finish – start) + ” milliseconds (Parallel using invoke command)”);

start = System.currentTimeMillis();
parallelArray = parallelArray.sort(); //Even if i convert this line to “parallelArray.sort()” clock time almost remains same
finish = System.currentTimeMillis();
System.out.println(“Time taken = ” + (finish – start) + ” milliseconds (Using Parallel Sort)”);

start = System.currentTimeMillis();
Arrays.sort(temp); //Even if i convert this line to “parallelArray.sort()” clock time almost remains same
finish = System.currentTimeMillis();
System.out.println(“Time taken = ” + (finish – start) + ” milliseconds (Using Arrays.sort())”);

}

private void shuttleSort(int[] from, int[] to, int low, int high) {
if (high – low == 1) {
return;
}
int middle = (low + high) / 2;
shuttleSort(to, from, low, middle);
shuttleSort(to, from, middle, high);

int p = low;
int q = middle;

if (high – low >= 4 && from[middle - 1] <= from[middle]) {
for (int i = low; i < high; i++) {
to[i] = from[i];
}
return;
}

for (int i = low; i = high || (p < middle && from[p] = 4 && from[middle - 1] <= from[middle]) {
for (int i = low; i < high; i++) {
to[i] = from[i];
}
return;
}

for (int i = low; i = high || (p < middle && from[p] <= from[q])) {
to[i] = from[p++];
}
else {
to[i] = from[q++];
}
}
}
}

}

Optimal!