La Performance de l'Aléatoire de la génération d'UUID avec Java 7 ou Java 6

Voici un essai en bêta 127.

Garder à l'esprit que ce test est irréaliste, au-delà de tout scénario du pire des cas je peux imaginer. Mon but était de calmer ceux qui, de mauvaise bouche de l'utilisation de UUIDs sans les faits, afin de sauvegarder leurs critiques.

Scénario:

• Une boucle d'un million d'appels à java.util.UUID.randomUUID()
  • Un essai avec juste que seul. (pas de conflit)
  • Un test avec contention, où 2 autres fils sont dans une boucle serrée, faire dix millions d'appels.
• Java beta 8 127
  • java version "1.8.0"
  • Java(TM) SE Runtime Environment (build 1.8.0-b127)
  • Java HotSpot(TM) 64-Bit Server VM (build 25.0-b69, en mode mixte)
• Exécuter à partir de Netbeans 7.4 IDE
• D'exécution à l'intérieur d'une machine virtuelle
  • Parallels 9 de la machine virtuelle
  • Mountain Lion
  • 3 cœurs virtuels
  • 4go de mémoire
• Mac mini (fin 2012)
  • Mavericks
  • Intel i7 quad-core avec Hyperthreading (8 apparente cœurs)
  • 16 go de mémoire

Sans Prétention

Exécution d'une boucle dans un thread, donc pas de contention sur la synchronisés méthodes/classes.

//Warm the random generator.
java.util.UUID uuid;
uuid = java.util.UUID.randomUUID();

long stop = 0;
long start = System.nanoTime();

int loops = 1000000;  //One million.
for ( int i = 0; i < loops; i++ ) {
    uuid = java.util.UUID.randomUUID();
}

stop = System.nanoTime();

long elapsed = ( stop - start );

System.out.println( "UUIDs: " + loops );
System.out.println( "Nanos: " + elapsed );
System.out.println( "Nanos per uuid: " + ( elapsed / loops ) + " ( micros per: " + ( elapsed / loops / 1000 ) + " )" );

Résultats

Sur 2 microsecondes par UUID.

Avec Contention

Similaire à ci-dessus, mais tout en faisant une boucle d'un million d'appels, nous avons deux autres threads d'exécution où chacun fait dix millions d'appels.

//Warm the random generator.
java.util.UUID uuid;
uuid = java.util.UUID.randomUUID();

int pass = 10_000_000 ;  //Ten million.
MyThread t1 = new MyThread( pass );
MyThread t2 = new MyThread( pass );


t1.start();
t2.start();
t3.start();

long stop = 0;
long start = System.nanoTime();

int loops = 1_000_000 ;  //One million.
for ( int i = 0; i < loops; i++ ) {
    uuid = java.util.UUID.randomUUID();
}

stop = System.nanoTime();

long elapsed = ( stop - start );

System.out.println( "UUIDs: " + loops );
System.out.println( "Nanos: " + elapsed );
System.out.println( "Nanos per uuid: " + ( elapsed / loops ) + " ( micros per: " + ( elapsed / loops / 1000 ) + " )" );

Et la classe définissant chaque thread...

class MyThread extends Thread {

    private int loops;

    public MyThread( int loops ) {
        this.loops = loops;
    }

    @Override
    public void run() {
        java.util.UUID uuid;
        for ( int i = 0; i < this.loops; i++ ) {
            uuid = java.util.UUID.randomUUID();
        }

    }
}

Résultats

Sur 20 microsecondes par UUID.

D'exécution ont été 14, 20, 20, 23, et 24 microsecondes par UUID (pas dans cet ordre). Donc dans des conditions extrêmes de contention n'était que d'environ 10 fois pire, avec 20 microsecondes étant acceptable dans aucun usage du monde réel, je l'ai connu.

OriginalL'auteur Basil Bourque

Le nombre de threads a un impact énorme sur les performances de la génération de l'Uuid. Ceci peut être expliqué par la recherche à la mise en œuvre de SecureRandom#nextBytes(byte[] qui génère des nombres aléatoires pour UUID.randomUUID():

synchronized public void nextBytes(byte[] bytes) {
    secureRandomSpi.engineNextBytes(bytes);
}

nextBytes est synchronized qui conduit à des pertes de performances lors de l'accès par les différents threads.

OriginalL'auteur Peter Keller

Un test junit exécuter sous jdk 1.7.0_40:

package org.corba.util;

import org.junit.Test;
import org.springframework.util.StopWatch;

import java.util.UUID;

/**
 * Test of performance of Java's UUID generation
 * @author Corba Da Geek
 * Date: 1/6/14
 * Time: 3:48 PM
 */
public class TestRandomUUID {
    private static final int ITERATIONS = 1000000;

    @Test
    public void testRandomUUID() throws Exception {
        //Set up data
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();

        //Run test
        for (int i = 0; i < ITERATIONS; i++)
            UUID.randomUUID();

        //Check results
        stopWatch.stop();
        final long totalTimeMillis = stopWatch.getTotalTimeMillis();
        System.out.println("Number of milliseconds: " + totalTimeMillis + " for " + ITERATIONS + " iterations.");
        System.out.println(String.format("Average time per iteration: %.7f ms", (float)totalTimeMillis/ITERATIONS));
    }
}

Et les résultats sur mon i5 ordinateur portable ont été:

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running org.corba.util.TestRandomUUID
Number of milliseconds: 677 for 1000000 iterations.
Average time per iteration: 0.0006770 ms
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.746 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

0.0006770 ms par invocation.

OriginalL'auteur CorbaTheGeek