Die Performance von Random UUID-Generierung mit Java 7 oder Java 6

Hier ist ein Testlauf in beta-127.

Beachten Sie, dass dieser test unrealistisch, jenseits aller worst-case-Szenario kann ich mir vorstellen. Mein Ziel war es, ruhig diejenigen, die schlecht über die Verwendung von UUIDs, ohne die Tatsachen zu sichern, Ihre Kritik.

Szenario:

• Eine enge Schleife von einer million Aufrufe java.util.UUID.randomUUID()
  • Ein test mit nur das allein. (keinen Streit)
  • Ein test mit Streit, wo die 2 anderen threads sind in einer engen Schleife machen zehn Millionen Anrufe.
• Java 8 beta-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, mixed mode)
• Ausführen von Netbeans 7.4 IDE
• Die Ausführung innerhalb einer virtuellen Maschine
  • Parallels 9 virtuellen Maschine
  • Mountain Lion
  • 3 virtuelle Kerne
  • 4 gigs Speicher
• Mac mini (Ende 2012)
  • Mavericks
  • Intel i7 quad-core mit Hyperthreading (8 ersichtlich Kerne)
  • 16 GB Speicher

, Ohne Streit

Läuft eine Schleife in einem thread, so dass kein Streit über die synchronisierten Methoden/Klassen.

//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 ) + " )" );

Ergebnisse

Über 2 Mikrosekunden pro UUID.

Mit Konflikten

Ähnlich wie oben, aber während einer Schleife von einer Millionen Aufrufe, haben wir zwei andere threads, wo jeder macht zehn Millionen Anrufe.

//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 ) + " )" );

Und die Klasse definieren, in jedem 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();
        }

    }
}

Ergebnisse

Über 20 Mikrosekunden per UUID.

Läuft mit 14, 20, 20, 23 und 24 Mikrosekunden pro UUID (nicht in dieser Reihenfolge). Also unter extremen Streit, wurde nur etwa 10 mal schlimmer, mit 20 Mikrosekunden als akzeptabel in der realen Nutzung, den ich kenne.

InformationsquelleAutor Basil Bourque

Die Anzahl der threads, hat einen großen Einfluss auf die Leistung bei der Erzeugung von UUIDs. Dies kann erklärt werden, indem man die Umsetzung von SecureRandom#nextBytes(byte[] dem die Zufallszahlen erzeugt, für UUID.randomUUID():

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

nextBytes ist synchronized führt zu erheblichen performance-Verlust, wenn der Zugriff von verschiedenen threads.

InformationsquelleAutor Peter Keller

Einem junit Testlauf unter 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));
    }
}

Und die Ergebnisse auf meinem i5 laptop waren:

-------------------------------------------------------
 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 pro Aufruf.

InformationsquelleAutor CorbaTheGeek