Почему мой многопоточный алгоритм сортировки не быстрее, чем моя единственная потоковая сортировка с объединением

Существуют определенные алгоритмы, время выполнения которых может уменьшиться значительно, когда каждый делит задачу и получает каждую часть, сделанную параллельно. Один из этих алгоритмов является сортировкой слиянием, где список разделен на бесконечно мало меньшие части и затем повторно объединен в отсортированном порядке. Я решил сделать эксперимент, чтобы протестировать, мог ли я я увеличивать скорость этого вида при помощи нескольких потоков. Я выполняю следующие функции в Java на Четырехъядерном Dell с Windows Vista.

Одна функция (случай управления) является просто рекурсивной:

// x is an array of N elements in random order
public int[] mergeSort(int[] x) {
    if (x.length == 1) 
        return x;

    // Dividing the array in half
    int[] a = new int[x.length/2];
    int[] b = new int[x.length/2+((x.length%2 == 1)?1:0)];
    for(int i = 0; i < x.length/2; i++) 
        a[i] = x[i];
    for(int i = 0; i < x.length/2+((x.length%2 == 1)?1:0); i++) 
        b[i] = x[i+x.length/2];

    // Sending them off to continue being divided
    mergeSort(a);
    mergeSort(b);

    // Recombining the two arrays
    int ia = 0, ib = 0, i = 0;
    while(ia != a.length || ib != b.length) {
        if (ia == a.length) {
            x[i] = b[ib];
            ib++;
        }
        else if (ib == b.length) {
            x[i] = a[ia];
            ia++;
        }
        else if (a[ia] < b[ib]) {
            x[i] = a[ia];
            ia++;
        }
        else {
            x[i] = b[ib];
            ib++;
        }
        i++;
    }

    return x;
}

Другой находится в функции 'выполнения' класса, который расширяет поток и рекурсивно создает два новых потока каждый раз, когда это называют:

public class Merger extends Thread
{
    int[] x;
    boolean finished;

    public Merger(int[] x)
    {
        this.x = x;
    }

    public void run()
    {
        if (x.length == 1) {
            finished = true;
            return;
        }

        // Divide the array in half
        int[] a = new int[x.length/2];
        int[] b = new int[x.length/2+((x.length%2 == 1)?1:0)];
        for(int i = 0; i < x.length/2; i++) 
            a[i] = x[i];
        for(int i = 0; i < x.length/2+((x.length%2 == 1)?1:0); i++) 
            b[i] = x[i+x.length/2];

        // Begin two threads to continue to divide the array
        Merger ma = new Merger(a);
        ma.run();
        Merger mb = new Merger(b);
        mb.run();

        // Wait for the two other threads to finish 
        while(!ma.finished || !mb.finished) ;

        // Recombine the two arrays
        int ia = 0, ib = 0, i = 0;
        while(ia != a.length || ib != b.length) {
            if (ia == a.length) {
                x[i] = b[ib];
                ib++;
            }
            else if (ib == b.length) {
                x[i] = a[ia];
                ia++;
            }
            else if (a[ia] < b[ib]) {
                x[i] = a[ia];
                ia++;
            }
            else {
                x[i] = b[ib];
                ib++;
            }
            i++;
        }

        finished = true;
    }
}

Оказывается, что функционируют, который не использует многопоточность, на самом деле работает быстрее. Почему? Операционная система и виртуальная машина Java не "связываются" достаточно эффективно для размещения различных потоков в различные ядра? Или я пропускаю что-то очевидное?