Le tri rapide se prête bien à une parallélisation, car le tri se fait récursivement sur des sous-tableaux indépendants et peut être délégué à des coprocessus avec pour seule synchronisation d’attendre que tous les coprocessus aient terminé leur tri pour affirmer que le sous-tableau est trié.
     
   let qsort cmp arr =
     let rec qsort lo hi =
     if hi - lo > 0 then
       begin
         let mid = (lo + hi) lsr 1 in
         if cmp arr.(mid) arr.(lo) then swap arr mid lo;
         if cmp arr.(hi) arr.(mid) then
           begin
             swap arr mid hi;
             if cmp arr.(mid) arr.(lo) then swap arr mid lo
           end;
         let pivot = arr.(mid) in
         let i = ref (lo + 1) and j = ref (hi - 1) in
         while !i < !j do
           while not (cmp pivot arr.(!i)) do incr i done;
           while not (cmp arr.(!j) pivot) do decr j done;
           if !i < !j then swap arr !i !j;
         done;
         let u = Thread.create (qsort lo) (!i-1) in
         let v = Thread.create (qsort (!i+1)) hi in
         Thread.join u;
         Thread.join v
       end in
     qsort 0 (Array.length arr - 1);;
Il serait correct, mais inintéressant d’intervertir les lignes 20 et 21. En effet, cela aurait pour conséquence d’attendre que la partie base du tableau soit triée pour lancer le tri de la partie haute. On obtiendrait alors le comportement d’un programme séquentiel, plus le coût des coprocessus sans en retirer aucun bénéfice.

En pratique, on devrait limiter la parallélisation à un facteur raisonnable et continuer de façon séquentielles au delà.