Ist eine GUID 100% der Zeit eindeutig?

Ist eine GUID 100% der Zeit eindeutig?

Wird es über mehrere Threads hinweg einzigartig bleiben?

Während nicht garantiert wird, dass jede generierte GUID eindeutig ist, ist die Gesamtzahl der eindeutigen Schlüssel (2 ¹²⁸ oder 3,4 × 10 ³⁸ ) so groß, dass die Wahrscheinlichkeit, dass dieselbe Nummer zweimal generiert wird, sehr gering ist. Betrachten Sie zum Beispiel das beobachtbare Universum, das etwa 5 × 10 ²² Sterne enthält. Jeder Stern könnte dann 6,8 × 10 ¹⁵ universell eindeutige GUIDs haben.

Aus Wikipedia .

Dies sind einige gute Artikel darüber, wie eine GUID erstellt wird (für .NET) und wie Sie dieselbe Anleitung in der richtigen Situation erhalten können.

https://ericlippert.com/2012/04/24/guid-guide-part-one/

https://ericlippert.com/2012/04/30/guid-guide-part-two/

https://ericlippert.com/2012/05/07/guid-guide-part-three/

Wenn Sie

Wenn Sie Angst vor denselben GUID-Werten haben, stellen Sie zwei davon nebeneinander.

Guid.NewGuid().ToString() + Guid.NewGuid().ToString();

Wenn Sie zu paranoid sind, setzen Sie drei.

Die einfache Antwort lautet ja.

Raymond Chen hat einen großartigen Artikel über GUIDs geschrieben und warum Teilzeichenfolgen von GUIDs nicht garantiert eindeutig sind. Der Artikel befasst sich eingehend mit der Art und Weise, wie GUIDs generiert werden, und den Daten, die sie verwenden, um die Eindeutigkeit sicherzustellen. Dies sollte einige Zeit dauern, um zu erklären, warum sie so sind :-)

Als Randnotiz habe ich mit Volume GUIDs in Windows XP herumgespielt. Dies ist ein sehr dunkles Partitionslayout mit drei Festplatten und vierzehn Volumes.

\\?\Volume{23005604-eb1b-11de-85ba-806d6172696f}\ (F:)
\\?\Volume{23005605-eb1b-11de-85ba-806d6172696f}\ (G:)
\\?\Volume{23005606-eb1b-11de-85ba-806d6172696f}\ (H:)
\\?\Volume{23005607-eb1b-11de-85ba-806d6172696f}\ (J:)
\\?\Volume{23005608-eb1b-11de-85ba-806d6172696f}\ (D:)
\\?\Volume{23005609-eb1b-11de-85ba-806d6172696f}\ (P:)
\\?\Volume{2300560b-eb1b-11de-85ba-806d6172696f}\ (K:)
\\?\Volume{2300560c-eb1b-11de-85ba-806d6172696f}\ (L:)
\\?\Volume{2300560d-eb1b-11de-85ba-806d6172696f}\ (M:)
\\?\Volume{2300560e-eb1b-11de-85ba-806d6172696f}\ (N:)
\\?\Volume{2300560f-eb1b-11de-85ba-806d6172696f}\ (O:)
\\?\Volume{23005610-eb1b-11de-85ba-806d6172696f}\ (E:)
\\?\Volume{23005611-eb1b-11de-85ba-806d6172696f}\ (R:)
                                     | | | | |
                                     | | | | +-- 6f = o
                                     | | | +---- 69 = i
                                     | | +------ 72 = r
                                     | +-------- 61 = a
                                     +---------- 6d = m

Es ist nicht so, dass die GUIDs sehr ähnlich sind, sondern die Tatsache, dass alle GUIDs die Zeichenfolge "mario" enthalten. Ist das ein Zufall oder gibt es eine Erklärung dafür?

Als ich nun nach Teil 4 in der GUID googelte, fand ich ungefähr 125.000 Treffer mit Volumen-GUIDs.

Fazit: Wenn es um Volume-GUIDs geht, sind sie nicht so eindeutig wie andere GUIDs.

Es sollte nicht passieren. Wenn .NET jedoch stark ausgelastet ist, können doppelte Anleitungen abgerufen werden. Ich habe zwei verschiedene Webserver mit zwei verschiedenen SQL-Servern. Ich ging zum Zusammenführen der Daten und stellte fest, dass ich 15 Millionen Guids und 7 Duplikate hatte.

Ja, eine GUID sollte immer eindeutig sein. Es basiert sowohl auf Hardware als auch auf Zeit und ein paar zusätzlichen Bits, um sicherzustellen, dass es einzigartig ist. Ich bin sicher, dass es theoretisch möglich ist, zwei identische zu erhalten, aber in einem realen Szenario äußerst unwahrscheinlich.

Hier ist ein großartiger Artikel von Raymond Chen über Guids:

https://blogs.msdn.com/oldnewthing/archive/2008/06/27/8659071.aspx

Guids sind statistisch eindeutig. Die Wahrscheinlichkeit, dass zwei verschiedene Clients dieselbe Guid generieren, ist unendlich gering (vorausgesetzt, es gibt keine Fehler im Guid-Generierungscode). Sie können sich auch Sorgen machen, dass Ihr Prozessor aufgrund einer kosmischen Strahlung ausfällt und heute 2 + 2 = 5 entscheidet.

Mehrere Threads, die neue Guids zuweisen, erhalten eindeutige Werte. Sie sollten jedoch feststellen, dass die von Ihnen aufgerufene Funktion threadsicher ist. In welcher Umgebung ist das?

Eric Lippert hat eine sehr interessante Artikelserie über GUIDs geschrieben.

Es gibt in der Größenordnung von 2 ³⁰ PCs auf der Welt (und natürlich viele Handheld-Geräte oder Nicht-PC-Computergeräte, die mehr oder weniger die gleiche Rechenleistung haben, aber wir können diese ignorieren). Nehmen wir an, wir stellen all diese PCs der Welt vor die Aufgabe, GUIDs zu generieren. Wenn jeder beispielsweise 2 ²⁰ GUIDs pro Sekunde erzeugen kann, haben Sie nach nur etwa 2 ⁷² Sekunden - 150 Billionen Jahre - eine sehr hohe Wahrscheinlichkeit, eine Kollision mit Ihrer spezifischen GUID zu erzeugen. Und die Wahrscheinlichkeit einer Kollision wird nach nur dreißig Billionen Jahren ziemlich gut.

• GUID-Leitfaden, Teil eins
• GUID Guide, Teil zwei
• GUID-Leitfaden, Teil drei

Theoretisch sind sie nicht eindeutig. Es ist möglich, immer wieder eine identische Guid zu generieren. Die Wahrscheinlichkeit, dass dies geschieht, ist jedoch so gering, dass Sie davon ausgehen können, dass sie einzigartig sind.

Ich habe zuvor gelesen, dass die Chancen so gering sind, dass Sie sich wirklich über etwas anderes Gedanken machen sollten - wie über das spontane Verbrennen Ihres Servers oder andere Fehler in Ihrem Code. Nehmen Sie also an, es ist einzigartig und bauen Sie keinen Code ein, um Duplikate zu "fangen" - verbringen Sie Ihre Zeit mit etwas, das wahrscheinlicher ist (dh mit irgendetwas anderem).

Ich habe versucht , meinem Blog-Publikum (nicht-technische Familienmitglieder) die Nützlichkeit von GUIDs zu beschreiben. Von dort (über Wikipedia) die Wahrscheinlichkeit, eine doppelte GUID zu generieren:

• 1 in 2 ^ 128
• 1 in 340 Undecillion (keine Sorge, Undecillion ist nicht im Quiz)
• 1 in 3,4 × 10 ^ 38
• 1 in 340.000.000.000.000.000.000.000.000.000.000.000.000.000

Keiner scheint die tatsächliche Mathematik der Wahrscheinlichkeit des Auftretens zu erwähnen.

Nehmen wir zunächst an, wir können den gesamten 128-Bit-Speicherplatz verwenden (Guid v4 verwendet nur 122 Bit).

Wir wissen, dass die allgemeine Wahrscheinlichkeit, KEIN Duplikat in nPicks zu erhalten, ist:

(1-1 / 2 ¹²⁸ ) (1-2 / 2 ¹²⁸ ) ... (1- (n-1) / 2 ¹²⁸ )

Da 2 ¹²⁸ viel viel größer ist als n, können wir dies wie folgt approximieren:

(1-1 / 2 ¹²⁸ ) ^{n (n-1) / 2}

Und weil wir davon ausgehen können, dass nes viel viel größer als 0 ist, können wir dies auf Folgendes approximieren:

(1-1 / 2 ¹²⁸ ) ^{n ^ 2/2}

Jetzt können wir dies mit der "akzeptablen" Wahrscheinlichkeit gleichsetzen, sagen wir 1%:

(1-1 / 2 ¹²⁸ ) ^{n ^} 2/2 = 0,01

Was wir lösen nund bekommen:

n = sqrt (2 · log 0,01 / log (1-1 / 2 ¹²⁸ ))

Welcher Wolfram Alpha wird 5.598318 × 10 ¹⁹

Um diese Zahl ins rechte Licht zu rücken, nehmen wir 10000 Maschinen mit jeweils einer 4-Kern-CPU, 4 GHz und 10000 Zyklen, um eine Guid zu generieren und nichts anderes zu tun. Es würde dann ~ 111 Jahre dauern, bis sie ein Duplikat erzeugen.

Von http://www.guidgenerator.com/online-guid-generator.aspx

Was ist eine GUID?

GUID (oder UUID) ist eine Abkürzung für "Global Unique Identifier" (oder "Universally Unique Identifier"). Es ist eine 128-Bit-Ganzzahl, mit der Ressourcen identifiziert werden. Der Begriff GUID wird im Allgemeinen von Entwicklern verwendet, die mit Microsoft-Technologien arbeiten, während UUID überall verwendet wird.

Wie einzigartig ist eine GUID?

128 Bit sind groß genug und der Generierungsalgorithmus ist so einzigartig, dass bei einer Generierung von 1.000.000.000 GUIDs pro Sekunde für 1 Jahr die Wahrscheinlichkeit eines Duplikats nur 50% beträgt. Oder wenn jeder Mensch auf der Erde 600.000.000 GUIDs generieren würde, gäbe es nur eine 50% ige Wahrscheinlichkeit für ein Duplikat.

Ich habe eine doppelte GUID erlebt.

Ich verwende den Desktop-Scanner Neat Receipts und er wird mit einer proprietären Datenbanksoftware geliefert. Die Software verfügt über eine Funktion zur Synchronisierung mit der Cloud, und beim Synchronisieren wurde immer wieder ein Fehler angezeigt. Ein Blick auf die Protokolle enthüllte die großartige Linie:

"Fehler": [{"Code": 1, "Nachricht": "Creator_guid: ist bereits vergeben", "Guid": "C83E5734-D77A-4B09-B8C1-9623CAC7B167"}]}

Ich war ein bisschen ungläubig, aber als ich einen Weg in meine lokale Ordnungsdatenbank fand und den Datensatz mit dieser GUID löschte, trat der Fehler auf.

Um Ihre Frage mit anekdotischen Beweisen zu beantworten, nein. Ein Duplikat ist möglich. Es ist jedoch wahrscheinlich, dass der Grund dafür nicht zufällig war, sondern dass die Standardpraxis in irgendeiner Weise nicht eingehalten wurde. (Ich bin einfach nicht so glücklich) Allerdings kann ich nicht sicher sagen. Es ist nicht meine Software.

Der Kundensupport war EXTREM höflich und hilfsbereit, aber sie müssen noch nie auf dieses Problem gestoßen sein, da sie nach mehr als 3 Stunden Telefonieren mit ihnen keine Lösung gefunden haben. (FWIW, ich bin sehr beeindruckt von Neat, und diese Panne, so frustrierend sie auch sein mag, hat meine Meinung zu ihrem Produkt nicht geändert.)

MSDN :

Es besteht eine sehr geringe Wahrscheinlichkeit, dass der Wert der neuen Guid alle Nullen oder gleich einer anderen Guid ist.

Wenn Ihre Systemuhr richtig eingestellt und nicht umwickelt ist und wenn Ihre Netzwerkkarte über einen eigenen MAC verfügt (dh Sie haben keinen benutzerdefinierten MAC festgelegt) und Ihr Netzwerkkartenanbieter keine MACs recycelt hat (was nicht vorgesehen ist) (was bekanntermaßen auftritt), und wenn die GUID-Generierungsfunktion Ihres Systems ordnungsgemäß implementiert ist, generiert Ihr System niemals doppelte GUIDs.

Wenn jeder auf der Erde, der GUIDs generiert, diese Regeln befolgt, sind Ihre GUIDs global eindeutig.

In der Praxis ist die Anzahl der Personen, die gegen die Regeln verstoßen, gering, und es ist unwahrscheinlich, dass ihre GUIDs "entkommen". Konflikte sind statistisch unwahrscheinlich.

Ist eine GUID 100% der Zeit eindeutig?

Nicht garantiert, da es mehrere Möglichkeiten gibt, eine zu generieren. Sie können jedoch versuchen, die Wahrscheinlichkeit zu berechnen, dass zwei identische GUIDs erstellt werden, und Sie erhalten die Idee: Eine GUID hat 128 Bit, daher gibt es 2 ¹²⁸ verschiedene GUIDs - viel mehr als es Sterne im bekannten Universum gibt. Lesen Sie den Wikipedia-Artikel für weitere Details.

Im allgemeineren Sinne ist dies als "Geburtstagsproblem" oder "Geburtstagsparadoxon" bekannt. Wikipedia hat einen ziemlich guten Überblick unter: Wikipedia - Geburtstagsproblem

In sehr groben Worten ist die Quadratwurzel der Größe des Pools eine grobe Annäherung an den Zeitpunkt, an dem Sie eine 50% ige Chance auf ein Duplikat erwarten können. Der Artikel enthält eine Wahrscheinlichkeitstabelle mit Poolgröße und verschiedenen Wahrscheinlichkeiten, einschließlich einer Zeile für 2 ^ 128. Bei einer Kollisionswahrscheinlichkeit von 1% würden Sie also erwarten, zufällig 2,6 * 10 ^ 18 128-Bit-Zahlen auszuwählen. Eine 50% ige Chance erfordert 2,2 * 10 ^ 19 Picks, während SQRT (2 ^ 128) 1,8 * 10 ^ 19 beträgt.

Das ist natürlich nur der Idealfall eines wirklich zufälligen Prozesses. Wie andere bereits erwähnt haben, hängt viel von diesem zufälligen Aspekt ab - wie gut sind der Generator und das Saatgut? Es wäre schön, wenn es Hardware-Unterstützung für diesen Prozess gäbe, die kugelsicherer wäre, außer dass alles gefälscht oder virtualisiert werden kann. Ich vermute, dass dies der Grund sein könnte, warum MAC-Adressen / Zeitstempel nicht mehr enthalten sind.

Für ein besseres Ergebnis ist es am besten, die GUID mit dem Zeitstempel zu versehen (nur um sicherzustellen, dass sie eindeutig bleibt).

Guid.NewGuid().ToString() + DateTime.Now.ToString();

GUID-Algorithmen werden normalerweise gemäß der v4-GUID-Spezifikation implementiert, bei der es sich im Wesentlichen um eine Pseudozufallszeichenfolge handelt. Leider fallen diese in die Kategorie "wahrscheinlich nicht eindeutig" von Wikipedia (ich weiß nicht, warum so viele Leute dieses Bit ignorieren): "... andere GUID-Versionen haben unterschiedliche Eindeutigkeitseigenschaften und -wahrscheinlichkeiten, die von garantierter Eindeutigkeit reichen zur wahrscheinlichen Nicht-Einzigartigkeit. "

Die pseudozufälligen Eigenschaften von Math.random()V8s JavaScript sind in ihrer Einzigartigkeit SCHRECKLICH. Kollisionen treten häufig bereits nach wenigen tausend Iterationen auf, aber V8 ist nicht der einzige Schuldige. Ich habe reale GUID-Kollisionen mit PHP- und Ruby-Implementierungen von v4-GUIDs gesehen.

Da die Skalierung der ID-Generierung über mehrere Clients und Cluster von Servern hinweg immer häufiger vorkommt, ist die Entropie von großer Bedeutung - die Wahrscheinlichkeit, dass derselbe zufällige Startwert zum Generieren einer ID verwendet wird, steigt (Zeit wird häufig als zufälliger Startwert verwendet) in Pseudozufallsgeneratoren) und GUID-Kollisionen eskalieren von "wahrscheinlich nicht eindeutig" zu "sehr wahrscheinlich, dass sie viele Probleme verursachen".

Um dieses Problem zu lösen, habe ich mich vorgenommen, einen ID-Algorithmus zu erstellen, der sicher skaliert und bessere Garantien gegen Kollisionen bietet. Dazu werden der Zeitstempel, ein speicherinterner Clientzähler, ein Clientfingerabdruck und zufällige Zeichen verwendet. Die Kombination von Faktoren erzeugt eine additive Komplexität, die besonders widerstandsfähig gegen Kollisionen ist, selbst wenn Sie sie auf mehrere Hosts skalieren:

http://usecuid.org/

Ich habe festgestellt, dass die GUIDs beim Testen von Einheiten mit mehreren Threads / Prozessen nicht eindeutig sind (auch?). Ich denke, das hat damit zu tun, dass alle anderen Töne gleich sind und dass Pseudozufallsgeneratoren identisch ausgesät werden (oder nicht ausgesät werden). Ich habe es verwendet, um eindeutige Dateinamen zu generieren. Ich fand, dass das Betriebssystem das viel besser kann :)

Trolling-Alarm

Sie fragen, ob GUIDs 100% eindeutig sind. Das hängt von der Anzahl der GUIDs ab, unter denen es eindeutig sein muss. Wenn sich die Anzahl der GUIDs der Unendlichkeit nähert, nähert sich die Wahrscheinlichkeit für doppelte GUIDs 100%.

Die Antwort von "Ist eine GUID 100% eindeutig?" ist einfach "Nein" .

• Wenn Sie eine 100% ige Eindeutigkeit der GUID wünschen, gehen Sie wie folgt vor.

  1. GUID generieren
  2. Überprüfen Sie, ob diese GUID in Ihrer Tabellenspalte vorhanden ist, in der Sie nach Eindeutigkeit suchen
  3. Wenn vorhanden, gehe zu Schritt 1, sonst zu Schritt 4
  4. Verwenden Sie diese GUID als eindeutig.

Der schwierigste Teil besteht nicht darin, eine doppelte Guid zu erstellen.

Der schwierigste Teil ist eine Datenbank, in der alle generierten Daten gespeichert werden, um zu überprüfen, ob sie tatsächlich dupliziert wurden.

Von WIKI:

Zum Beispiel beträgt die Anzahl der zufälligen UUIDs der Version 4, die generiert werden müssen, um eine 50% ige Wahrscheinlichkeit für mindestens eine Kollision zu haben, 2,71 Billionen, berechnet wie folgt:

Geben Sie hier die Bildbeschreibung ein

Diese Zahl entspricht einer Generierung von 1 Milliarde UUIDs pro Sekunde für ungefähr 85 Jahre, und eine Datei mit diesen vielen UUIDs mit 16 Bytes pro UUID würde ungefähr 45 Exabyte groß sein, ein Vielfaches größer als die größten derzeit existierenden Datenbanken die Größenordnung von Hunderten von Petabyte

GUID steht für Global Unique Identifier

In Kürze: (der Hinweis ist im Namen)

Im Detail: GUIDs sind einzigartig gestaltet. Sie werden nach einer zufälligen Methode berechnet, die auf der Uhr des Computers und dem Computer selbst basiert. Wenn Sie viele GUIDs in derselben Millisekunde auf demselben Computer erstellen, ist es möglich, dass sie übereinstimmen, aber für fast alle normalen Vorgänge sollten sie als eindeutig betrachtet werden.