2013-06-26 13 views

risposta

32

sorta parallelo utilizza filettatura. È più veloce quando ci sono molto di elementi. L'overhead per la parallelizzazione diventa abbastanza piccolo su array più grandi, ma è grande per quelli più piccoli.

Date un'occhiata a questa tabella (ovviamente, i risultati dipendono dai processi di CPU, sfondo, ecc):

enter image description here

Tratto da questo link: http://www.javacodegeeks.com/2013/04/arrays-sort-versus-arrays-parallelsort.html

+1

Non c'è nulla di così "troppo piccolo" quando si parla di overhead. Idealmente vorrei 0.) – Trejkaz

+4

Le misurazioni del tempo sono state condotte in modo assolutamente errato in questo test. Si noti inoltre che se l'array di input è inferiore a 4096, parallelSort chiama semplicemente l'algoritmo di ordinamento sequenziale. Credi davvero che il controllo della lunghezza aggiuntiva richieda 3 ms per 602 elementi? –

+0

Ehi @TagirValeev. So che questa domanda è vecchia, ma ho pensato di far notare che la differenza di tempo per 602 non è probabilmente dovuta al controllo della lunghezza; almeno questo controllo non è specificamente da incolpare. Suppongo che questi tempi non fossero la media di test multipli, quindi forse questo era un altro processo in esecuzione sul computer che ha causato la differenza di 3ms qui. Solo qualche spunto di riflessione. Ma sono d'accordo sul fatto che le misurazioni siano state condotte in modo errato, poiché la precisione è ottenuta solo attraverso un numero maggiore di casi di test. Ci sono altri articoli che mostrano guadagni di prestazioni simili, però. – adpro

13

Arrays.parallelSort():

Il metodo utilizza un valore di soglia e qualsiasi array di dimensione minore rispetto al valore di soglia viene filtrate usando l'Array # sort() API (cioè ordinamento sequenziale). E la soglia è calcolato considerando il parallelismo della macchina, dimensione dell'array e viene calcolata come:

private static final int getSplitThreshold(int n) { 
int p = ForkJoinPool.getCommonPoolParallelism(); 
int t = (p > 1) ? (1 + n/(p << 3)) : n; 
return t < MIN_ARRAY_SORT_GRAN ? MIN_ARRAY_SORT_GRAN : t; 
} 

volta che il suo deciso se ordinare l'array in parallelo o in serie, relativo ora decidere come dividere l'array in più parti e quindi assegnare ciascuna parte a un'attività Fork/Join che si occuperà di ordinarla e quindi un'altra attività Fork/Join che si occuperà di unire gli array ordinati. L'implementazione in JDK 8 utilizza questo approccio:

  • Dividere l'array in 4 parti.

  • Ordinare le prime due parti e unirle.

  • Ordinare le due parti successive e unirle. I passaggi precedenti vengono ripetuti ricorsivamente con ciascuna parte finché la dimensione della parte da ordinare non è inferiore al valore di soglia calcolato in precedenza.

È inoltre possibile leggere i dettagli di implementazione nel Javadoc

L'algoritmo di ordinamento è un sort-merge parallelo che rompe la matrice in sotto-matrici che sono essi stessi ordinato e poi uniti. Quando la lunghezza dell'array secondario raggiunge una granularità minima, la matrice secondaria viene ordinata utilizzando il metodo Arrays.sort appropriato. Se la lunghezza dell'array specificato è inferiore alla granularità minima, viene ordinata utilizzando il metodo Arrays.sort appropriato. L'algoritmo richiede uno spazio di lavoro non superiore alla dimensione dell'intervallo specificato dell'array originale. Il pool comune ForkJoin viene utilizzato per eseguire attività parallele.

Array.sort():

Questo utilizza merge sort O Tim Ordina sotto per ordinare il contenuto. Tutto questo viene fatto in sequenza, anche se l'ordinamento di fusione utilizza la tecnica divide and conquer, il tutto in ordine sequenziale.

Source

2

In poche parole, parallelSort utilizza più thread. Questo article ha molti più dettagli se vuoi davvero saperlo.

2

Da questa link

implementazioni smistamento corrente forniti dal Java Collections quadro (Collections.sort e Arrays.sort) tutto eseguire l'ordinamento operazione sequenziale nel thread chiamante. Questo miglioramento sarà offrendo lo stesso set di operazioni di ordinamento attualmente fornito dalla classe Array di , ma con un'implementazione parallela che utilizza il framework Forcella/Join . Queste nuove API sono ancora sincrone per quanto riguarda per il thread chiamante in quanto non procederà oltre l'operazione di ordinamento finché l'ordinamento parallelo non è completo.

3

È possibile fare riferimento a the javadoc, che spiega che l'algoritmo utilizza più thread se la matrice è sufficientemente grande:

L'algoritmo di ordinamento è una sorta-merge parallelo che rompe la matrice in sub-array che sono ordinati e poi uniti. Quando la lunghezza dell'array secondario raggiunge una granularità minima, la matrice secondaria viene ordinata utilizzando il metodo Arrays.sort appropriato. [...] Il pool comune ForkJoin viene utilizzato per eseguire attività parallele.

4

Le differenze principali tra sia l'algoritmo sono come seguono:

1. Arrays.sort(): è un ordinamento sequenziale.

  • L'API utilizza thread singolo per l'operazione.
  • L'API impiega un po 'più di tempo per eseguire l'operazione.

2. Arrays.ParallelSort(): è un ordinamento parallelo.

L'API utilizza più thread.

  • L'API impiega il tempo minore rispetto a Sort().

Per ulteriori risultati, tutti dobbiamo aspettare JAVA 8, credo !! Saluti !!

1

Array.sort(myArray);

È ora possibile utilizzare -

Arrays.parallelSort(myArray);

Questo si romperà automaticamente la raccolta di destinazione in più parti, che verranno ordinati in modo indipendente in un certo numero di core e poi raggruppati di nuovo insieme . L'unica avvertenza qui è che quando viene chiamato in ambienti altamente multi-thread, come ad esempio un contenitore Web occupato, i vantaggi di questo approccio inizieranno a diminuire (di oltre il 90%) a causa del costo degli switch di contesto CPU aumentati.

Source- link

0

Arrays.sort() utilizza un'unica filettatura per ordinare gli elementi ma Arrays.ParallelSort() volontà utilizza più thread.
parallelsort richiederà meno tempo rispetto alla normale ordinamento.