Tri avec plusieurs threads

Question

J'essaie de trier un nombre d'entiers en utilisant 4 threads, en séparant le tableau puis en le recombinant. Je pense que j'ai accompli en utilisant 2 threads, quelqu'un peut-il aider d'ici comment je passerais à l'utilisation de 4?

import java.util.Random; 
import java.util.Arrays; 

public class threadSort implements Runnable { 
private static final int L = 64; 
private static int[] nums; 
private static Random rand; 

public void run() { 
    //sorting upper half 
    Arrays.sort(nums, nums.length/2, nums.length); 
} 

public static void main(String args[]) throws InterruptedException { 

    nums = new int[L]; 
    rand = new Random(); 

    //fill the array 
    for(int i=0; i<nums.length; i++) { 
     nums[i] = rand.nextInt(10); 
    } 

    Thread t = new Thread(new threadSort()); 
    t.start(); 

    //sorting lower half 
    Arrays.sort(nums, 0, nums.length/2); 

    t.join(); 

    /* merge */ 
    int j = 0; 
    int k = nums.length/2; 
    int[] tmp = new int[nums.length]; 
    for (int i=0; i<tmp.length; i++){ 
     if (j < nums.length/2) { 
      if (k < nums.length) { 
       if (nums[j] < nums[k]) { 
        tmp[i] = nums[j++]; 
       } else { 
        tmp[i] = nums[k++]; 
       } 
      } else { 
       /* reached end of second half, copy first*/ 
       tmp[i] = nums[j++]; 
      } 
     } else { 
      /* reached end of 1st half, copy 2nd*/ 
      tmp[i] = nums[k++]; 
     } 
    } 
    nums = tmp; 


    //Testing Sort and Total 
    int count = 0; 

    for(int i=0; i<nums.length; i++){ 
    System.out.print(nums[i] + " "); 
    count++; 
    } 
    System.out.println(); 
    System.out.println("Total amount of Integers = " + count); 
} 

} 

thats ce que j'ai jusqu'à présent Je veux rester avec ce que j'ai, mais jeter 2 autres fils dans

Answer 1

La meilleure façon est d'utiliser forkjoin. Fondamentalement, vous divisez récursivement vos données en morceaux binaires jusqu'à ce que vous ayez un morceau assez petit avec lequel vous voulez travailler. L'utilisation du framework forkjoin de DL est un exercice amusant, mais si vous voulez rester simple, poursuivez votre lecture.

Tout ce que vous avez à faire est d'appeler votre algorithme actuel deux fois. Autrement dit, utilisez-le pour casser vos données de moitié. Ensuite, appelez votre algorithme sur chaque moitié. Lorsque les deux sont faites, fusionner leurs résultats.