Многопоточная сортировка слиянием (mergesort)

public class ThreadSort {
    int TN=0;
    int threadNum = 0;
    SortThread[] threads;
    public class SortThread extends Thread{
        Object []array;
        public SortThread(Object[]a){
            array=new Object[a.length];
            System.arraycopy(a, 0, array, 0, a.length);
        }
        @Override
        public void run(){
 
            MergeSort(array);
        }
    }
    public  ThreadSort(int thread){
        this.TN=thread;
        threads = new SortThread[thread];
    }
 
        public void MergeSort(Object[] a) {
 
 
            int n = a.length;
            if (n < 2) {
                return;
            }
            int mid = n / 2;
            Object[] l = new Object[mid];
            Object[] r = new Object[n - mid];
 
            for (int i = 0; i < mid; i++) {
                l[i] = a[i];
            }
            for (int i = mid; i < n; i++) {
                r[i - mid] = a[i];
            }
            if(this.threadNum > this.TN){
                this.threadNum = this.threadNum - this.TN;
            }
            int t1 = this.threadNum;
 
 
 
 
            threads[t1] = new SortThread(l);
                    threads[t1].start();
            this.threadNum++;
            if(this.threadNum >= this.TN){
                this.threadNum = this.threadNum - this.TN;
            }
            int t2 = this.threadNum;
            threads[t2] = new SortThread(r);
                threads[t2].start();
            for(int i = 0; i < threads.length; ++i) {
                if(threads[i] != null) {
                    try {
                        threads[t1].join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    try {
                        threads[t2].join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
 
 
            merge(a, l, r, l.length, r.length);
 
        }
        public static void merge(Object[] a, Object[] l, Object[] r, int left, int right) {
            synchronized (a) {
                synchronized (l) {
                    synchronized (r) {
                        int i = 0, j = 0, k = 0;
                        while (i < left && j < right) {
                            if ((((Comparable) l[i]).compareTo(r[j])) >= 0) {
                                a[k++] = l[i++];
                            } else {
                                a[k++] = r[j++];
                            }
                        }
                    }
                }
            }
        }
}

import java.lang.reflect.Array;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
 
public class Main {
    public static void main(String[] args) {
        Integer[] arr = {5, 3, 5, 67, 2};
        NedoSort.parallelMergeSort(arr, Integer::compareTo);
        System.out.println(Arrays.toString(arr));
    }
}
 
class NedoSort {
    public static <T> void parallelMergeSort(T[] array, Comparator<? super T> comparator) {
        if (array.length < 2) return;
        final var queueTask = new LinkedBlockingQueue<Map.Entry<T[], T[]>>(Math.max(2, array.length / 2));
        final var queueResult = new LinkedBlockingQueue<T[]>(Math.max(2, array.length / 2));
        final int NT = Runtime.getRuntime().availableProcessors();
        final var threadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        try {
            for (int i = 0; i < NT; ++i) threadPool.execute(new Merger<>(queueTask, queueResult, comparator));
            T[]
                    t1 = (T[]) Array.newInstance(array.getClass().getComponentType(), 2),
                    t2 = (T[]) Array.newInstance(array.getClass().getComponentType(), 2);
            int q = 0;
            for (T t : array) {
                if (q < 2) {
                    t1[q++] = t;
                } else {
                    t2[q++ - 2] = t;
                }
                if (q == 4) {
                    q = 0;
                    if (comparator.compare(t1[0], t1[1]) > 0) swap(t1, 0, 1);
                    if (comparator.compare(t2[0], t2[1]) > 0) swap(t2, 0, 1);
                    queueTask.put(new AbstractMap.SimpleEntry<>(Arrays.copyOf(t1, 2), Arrays.copyOf(t2, 2)));
                }
            }
            if (q > 0) {
                if (q > 1 && comparator.compare(t1[0], t1[1]) > 0) swap(t1, 0, 1);
                queueResult.put(Arrays.copyOf(t1, Math.min(q, 2)));
            }
            if (q > 2) {
                if (q > 3 && comparator.compare(t2[0], t2[1]) > 0) swap(t2, 0, 1);
                queueResult.put(Arrays.copyOf(t2, q - 2));
            }
            T[] t;
            while ((t = queueResult.take()).length < array.length) {
                queueTask.put(new AbstractMap.SimpleEntry<>(t, queueResult.take()));
            }
            System.arraycopy(t, 0, array, 0, array.length);
 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            threadPool.shutdownNow();
        }
    }
 
    private static <T> T[] merge(T[] t1Arr, T[] t2Arr, Comparator<? super T> comparator) {
        T[] result = (T[]) Array.newInstance(t1Arr.getClass().getComponentType(), t1Arr.length + t2Arr.length);
        int qt1 = 0, qt2 = 0, qr = 0;
        while (qt1 < t1Arr.length && qt2 < t2Arr.length) {
            if (comparator.compare(t1Arr[qt1], t2Arr[qt2]) < 0) {
                result[qr] = t1Arr[qt1++];
            } else {
                result[qr] = t2Arr[qt2++];
            }
            qr++;
        }
        if (t2Arr.length - qt2 > 0) System.arraycopy(t2Arr, qt2, result, qr, t2Arr.length - qt2);
        if (t1Arr.length - qt1 > 0) System.arraycopy(t1Arr, qt1, result, qr, t1Arr.length - qt1);
        return result;
    }
 
    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }
 
    private record Merger<T>(BlockingQueue<? extends Map.Entry<T[], T[]>> queueTask,
                             BlockingQueue<? super T[]> queueResult,
                             Comparator<? super T> comparator) implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    var entry = queueTask.take();
                    queueResult.put(merge(entry.getValue(), entry.getKey(), comparator));
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}