Les collisions GUID sont-elles possibles?

, Fondamentalement, ils ne sont pas possibles !, les chances sont astronomiquement faible.

Mais... Je suis la seule personne que je connaisse au monde, que a eu une colision GUID une fois (yep!).

Et, j'en suis sûr, et que ce n'était pas une erreur.

Comment est-ce arrivé, dans une petite application qui fonctionnait sur Pocket PC, à la fin d'une opération, une commande qui a un GUID généré doit être émise. La commande après son exécution sur le serveur était stocké dans une table de commande sur le serveur avec la date d'exécution. Un jour, lorsque je déboguais, j'ai émis la commande module (avec le GUID nouvellement généré attaché) et rien ne s'est passé. Je l'ai fait à nouveau (avec le même guid, car le guid n'a été généré qu'une seule fois au début de l'opération), et encore, et rien, essayant finalement de savoir pourquoi la commande ne s'exécute pas, j'ai vérifié la table de commandes, et le même GUID que le courant a été inséré il y a 3 semaines. Ne pas croire ceci, j'ai restauré une base de données à partir de 2 semaines de sauvegarde, et le guid était là. Vérifié le code, le nouveau guid a été fraîchement généré sans aucun doute à ce sujet. Pow GUID collision, est arrivé une seule fois, mais je souhaite vraiment que je l'aurais gagné au loto à la place, la chance est plus grande:).

Edit: certains facteurs auraient pu considérablement augmenter les chances que cela se produise, l'application s'exécutait sur L'émulateur PocketPC, et l'émulateur a une fonction d'état de sauvegarde, ce qui signifie que chaque fois que le l'état est restauré l'heure locale est également restaurée et le guid est basé sur la minuterie interne....de plus, l'algorithme de génération de guid pour le framework compact pourrait être moins complet que par exemple celui de COM...

Ils sont théoriquement possibles, mais avec 3. 4e38 nombres possibles, si vous créez des dizaines de milliards de GUID dans une année la chance d'avoir un doublon est 0.00000000006 (Source).

Si deux utilisateurs se retrouvaient avec le même GUID, je parierais qu'il y a un bug dans le programme qui provoque la copie ou le partage des données.

Regardons D'abord le risque de collision de deux GUID. Ce n'est pas, comme d'autres réponses l'ont indiqué, 1 sur 2^128 (10^38) à cause du paradoxe d'anniversaire , ce qui signifie que pour une probabilité de 50% de collision de deux GUID, la probabilité est en fait 1 sur 2^64 (10^19) ce qui est beaucoup plus petit. Cependant, il s'agit toujours d'un très grand nombre, et en tant que tel, la probabilité de collision en supposant que vous utilisez un nombre raisonnable de GUID est faible.

Notez également que les GUID ne contiennent pas d'horodatage ou L'adresse MAC comme beaucoup de gens semblent aussi croire. Cela était vrai pour les GUID v1 mais Maintenant, les GUID v4 sont utilisés, qui sont simplement un nombre pseudo-aléatoire ce qui signifie que la possibilité de collision est sans doute plus élevée car ils ne sont plus uniques à un temps et à une machine.

Donc essentiellement la réponse est oui, les collisions sont possibles. Mais ils sont très peu probables.

Edit: correction de dire 2^64

Les chances de collision de deux GUID aléatoires (~1 sur 10^38) sont inférieures à celles de ne pas détecter un paquet TCP/IP corrompu (~1 sur 10^10). http://wwwse.inf.tu-dresden.de/data/courses/SE1/SE1-2004-lec12.pdf , page 11. Cela est également vrai des lecteurs de disque, lecteurs de cd, etc...

Les GUID sont statistiquement uniques et les données que vous lisez à partir de la base de données ne sont statistiquement correctes.

Je considère rasoir d'Occam comme un bon guide dans ce cas. Il est incroyablement peu probable que vous ayez une collision GUID. Il est beaucoup plus probable que vous ayez un bug, ou quelqu'un qui joue avec vos données.

Voir L'article globally unique Identifier de Wikipedia. Il existe plusieurs façons de générer des GUID. Apparemment, le vieux (?) façon utilisée Adresse Mac, un horodatage jusqu'à une unité très courte et un compteur unique (pour gérer les générations rapides sur le même ordinateur), afin de les faire dupliquer est presque impossible. Mais ces GUID ont été supprimés parce qu'ils pourraient être utilisés pour traquer les utilisateurs...

Je ne suis pas sûr du nouvel algorithme utilisé par Microsoft (l'article dit qu'une séquence de GUID peut être prédit, on dirait qu'ils n'utilisent plus l'horodatage? L'article de Microsoft lié ci-dessus dit autre chose...).

Maintenant, les GUID sont soigneusement conçus pour être, par leur nom, globalement uniques, donc je vais risquer que ce soit impossible, ou de très très très faible probabilité. Je regarde ailleurs.

Deux machines Win95 qui ont des cartes ethernet avec des adresses MAC en double émettront des GUID en double dans des conditions étroitement contrôlées, surtout si, par exemple, l'alimentation s'éteint dans le bâtiment et qu'elles démarrent toutes les deux exactement au même moment.

Je sais que les gens aiment la réponse feel-good que les GUID sont magiques et garantis uniques, mais en réalité, la plupart des GUID ne sont que des nombres aléatoires de 121 bits (sept des bits sont gaspillés sur le formatage). Si vous ne vous sentez pas à l'aise avec un grand nombre aléatoire, vous ne devriez pas vous sentir à l'aise avec un GUID.

Le code utilisé pour générer un GUID pourrait-il contenir un bug? Oui, bien sûr. Mais la réponse est la même que pour un bogue du compilateur - votre propre code est plus susceptible d'être bogué, alors regardez d'abord.

Bien sûr, c'est possible....Probable? Probablement pas, mais c'est possible.

Rappelez-vous, la même machine génère chaque GUID (le serveur), donc beaucoup de "caractère aléatoire" basé sur des informations spécifiques à la machine est perdu.

Juste pour les sourires, essayez le script suivant... (fonctionne sur SQL 2005, pas sûr de 2000)

declare @table table
(
    column1 uniqueidentifier default (newid()),
    column2 int,
    column3 datetime default (getdate())
)

declare @counter int

set @counter = 1

while @counter <= 10000
begin
    insert into @table (column2) values (@counter)
    set @counter = @counter + 1
end

select * from @table

select * from @table t1 join @table t2 on t1.column1 = t2.column1 and t1.column2 != t2.column2

L'exécution répétée (prend moins d'une seconde) produit une plage assez large à partir de la première sélection, même avec un intervalle de temps extrêmement court. Jusqu'à présent, la deuxième sélection n'a rien produit.

Impossible si les utilisateurs ont des machines avec des cartes réseau, et même si elle est toujours extrêmement marginal presque risque théorique.

Personnellement, je regarderais ailleurs car il est plus probable qu'il s'agisse d'un bug plutôt que D'un conflit GUID...

Fournissant bien sûr que vous ne coupez pas les bits du GUID pour le rendre plus court.

Bien sûr que c'est possible, et peut-être même probable. Ce n'est pas comme si chaque GUID se trouvait dans une partie aléatoire de l'espace numérique possible. Dans le cas où deux threads tenteraient d'en générer un simultanément, sauf une sorte de fonction GUID centralisée avec un sémaphore autour, ils pourraient se retrouver avec la même valeur.

Je vais préfacer ceci par "Je ne suis pas une personne de réseautage, donc je peux faire des phrases complètement incohérentes après.".

Quand je travaillais à L'Illinois State University, nous avions deux ordinateurs de bureau Dell, commandés à des moments différents. Nous avons mis le premier sur le réseau, mais quand nous avons essayé de mettre le second sur le réseau, nous avons commencé à recevoir de fou erreurs. Après beaucoup de dépannage, il a été déterminé que les deux machines produisaient le même GUID (Je ne sais pas exactement pour quoi, mais il a fait les deux inutilisable sur le réseau). Dell a effectivement remplacé les deux machines comme défectueuses.

Il est très peu probable que vous rencontriez des collisions GUID si vous les générez via quelque chose comme la fonction NEWID() dans SQL Server (bien que possible, comme d'autres réponses l'ont souligné). Une chose qu'ils n'ont pas souligné est qu'il est en fait très probable que vous rencontrerez des collisions si vous générez des GUID en JavaScript sur les navigateurs dans la nature. Non seulement il y a parfois des problèmes dans le RNG dans différents navigateurs, mais j'ai aussi rencontré des problèmes où le Google les araignées semblent mettre en cache les résultats de fonctions comme ça, et ont fini par passer à plusieurs reprises le même GUID à nos systèmes.

Voir les différentes réponses ici pour plus de détails:

Collisions lors de la génération D'UUID en JavaScript?