सरल प्रमाण जो GUID अद्वितीय नहीं है [बंद]

Question

मैं यह साबित करना चाहूंगा कि एक साधारण परीक्षण कार्यक्रम में एक GUID अद्वितीय नहीं है। मुझे उम्मीद है कि निम्नलिखित कोड घंटों तक चलेगा, लेकिन यह काम नहीं कर रहा है। मैं इसे कैसे कारगर बना सकता हूं?

BigInteger begin = new BigInteger((long)0);
BigInteger end = new BigInteger("340282366920938463463374607431768211456",10);  //2^128
for(begin; begin<end; begin++)
  Console.WriteLine(System.Guid.NewGuid().ToString());

मैं C # का उपयोग कर रहा हूं।

Comments

एक सॉफ्टवेयर डेवलपर के रूप में, यदि कोई उपयोगकर्ता आपके पास आया और "यह काम नहीं कर रहा है" तो आप क्या कहेंगे?

— जोशजोर्डन

कई खरब वर्ष प्रतीक्षा करें।

— हॉब्स

Upmodded क्योंकि यह सबसे मनोरंजक चीज है जिसे मैंने आज ऑनलाइन देखा है।

— 1

@ जिक्रवे - लोल। मुझे इस प्रश्न के बारे में कुछ भी परेशान करने में दिक्कत हो रही है जो मौलिक रूप से गलत नहीं है। जितनी देर मैं इसे देखता हूं, उतना ही मजेदार होता है।

— tylerl

यह केवल विश्व स्तर पर अद्वितीय है, इसलिए यह हमारे ग्रह पर केवल अद्वितीय है। यदि आप वास्तव में एक अद्वितीय आईडी चाहते हैं, तो आपको सार्वभौमिक रूप से अद्वितीय आईडी (UUID) का उपयोग करने की आवश्यकता है । मुझे लगता है कि आप केवल हमारे ब्रह्मांड के भीतर विशिष्टता में रुचि रखते हैं। :-)

— tvanfosson

Answer 1

काई, मैंने एक कार्यक्रम प्रदान किया है जो आप थ्रेड्स का उपयोग करना चाहते हैं। यह निम्नलिखित शर्तों के तहत लाइसेंस प्राप्त है: आपको सीपीयू कोर प्रति 0.0001 डॉलर प्रति घंटे का भुगतान करना होगा जो आप इसे चलाते हैं। प्रत्येक कैलेंडर माह के अंत में शुल्क देय हैं। कृपया मुझे अपने पेपाल खाते के विवरण के लिए अपनी जल्द से जल्द सुविधा के लिए संपर्क करें।

using System;
using System.Collections.Generic;
using System.Linq;

namespace GuidCollisionDetector
{
    class Program
    {
        static void Main(string[] args)
        {
            //var reserveSomeRam = new byte[1024 * 1024 * 100];     // This indeed has no effect.

            Console.WriteLine("{0:u} - Building a bigHeapOGuids.", DateTime.Now);
            // Fill up memory with guids.
            var bigHeapOGuids = new HashSet<Guid>();
            try
            {
                do
                {
                    bigHeapOGuids.Add(Guid.NewGuid());
                } while (true);
            }
            catch (OutOfMemoryException)
            {
                // Release the ram we allocated up front.
                // Actually, these are pointless too.
                //GC.KeepAlive(reserveSomeRam);
                //GC.Collect();
            }
            Console.WriteLine("{0:u} - Built bigHeapOGuids, contains {1} of them.", DateTime.Now, bigHeapOGuids.LongCount());


            // Spool up some threads to keep checking if there's a match.
            // Keep running until the heat death of the universe.
            for (long k = 0; k < Int64.MaxValue; k++)
            {
                for (long j = 0; j < Int64.MaxValue; j++)
                {
                    Console.WriteLine("{0:u} - Looking for collisions with {1} thread(s)....", DateTime.Now, Environment.ProcessorCount);
                    System.Threading.Tasks.Parallel.For(0, Int32.MaxValue, (i) =>
                    {
                        if (bigHeapOGuids.Contains(Guid.NewGuid()))
                            throw new ApplicationException("Guids collided! Oh my gosh!");
                    }
                    );
                    Console.WriteLine("{0:u} - That was another {1} attempts without a collision.", DateTime.Now, ((long)Int32.MaxValue) * Environment.ProcessorCount);
                }
            }
            Console.WriteLine("Umm... why hasn't the universe ended yet?");
        }
    }
}

पुनश्च: मैं समानांतर एक्सटेंशन लाइब्रेरी को आज़माना चाहता था। वह तो आसान था।

और नियंत्रण प्रवाह के रूप में OutOfememoryException का उपयोग करना सिर्फ गलत लगता है।

संपादित करें

खैर, ऐसा लगता है कि यह अभी भी वोटों को आकर्षित करता है। तो मैंने GC.KeepAlive () मुद्दा तय कर लिया है। और इसे C # 4 के साथ चलाने के लिए बदल दिया।

और मेरी समर्थन शर्तों को स्पष्ट करने के लिए: समर्थन केवल 28 / फरवरी / 2010 को उपलब्ध है। कृपया उस दिन केवल समर्थन अनुरोध करने के लिए टाइम मशीन का उपयोग करें।

EDIT 2 हमेशा की तरह, जीसी एक बेहतर काम करता है जितना मैं मेमोरी को मैनेज करने में करता हूं; किसी भी पिछले प्रयास में यह खुद को विफल करने के लिए बर्बाद कर रहे थे।

Comments

वह आखिरी कंसोल। मुझे लाइटलाइन ने मुझे असली मेहनत से हंसाया। मुझे लगता है कि आपको CommonlyAcceptedCosmologicTheoriesWrongExceptionइसके बजाय फेंक देना चाहिए ।

— आर। मार्टिनो फर्नांडिस

क्या इसे स्वीकृत के रूप में चिह्नित करने का मतलब यह भी है कि @Kaios द्वारा निर्धारित शर्तों को स्वीकार करता है?

— केबी

सेटिंग reserveSomeRam = null;वास्तव में कुछ भी पूरा नहीं करता है।

— डेविन बी

@devinb कृपया समझाएं? ऐसा लगता है कि यह बाइट्स को मुक्त कर रहा है जिसे पहले आवंटित किया गया था ताकि जीसी Collect()यह कर सके । यह कुछ भी पूरा क्यों नहीं करता है?

— मिथ्ज़

GuidCollisionDetector। नाम में संभावित क्षमता है

— उफुक हकीओउल्लार

Answer 2

यह बहुत अधिक घंटों तक चलेगा। यह मानते हुए कि यह 1 गीगाहर्ट्ज पर है (जो यह नहीं होगा - यह उससे बहुत धीमा होगा), यह 10790283070806014188970 वर्षों तक चलेगा। जो ब्रह्मांड की आयु से लगभग 83 बिलियन गुना अधिक लंबा है।

मूरेस कानून की मानें , तो इस कार्यक्रम को नहीं चलाने, कई सौ वर्षों तक प्रतीक्षा करने और इसे कंप्यूटर पर चलाने के लिए यह बहुत तेज होगा जो कि अरबों गुना तेज है। वास्तव में, कोई भी प्रोग्राम जिसे चलाने में अधिक समय लगता है, वह CPU की गति को दोगुना (लगभग 18 महीने) तक ले जाता है, यदि आप सीपीयू की गति बढ़ने तक प्रतीक्षा करते हैं और इसे चलाने से पहले एक नया सीपीयू खरीदते हैं, जब तक कि आप इसे नहीं लिखते, तब तक यह पूरा हो जाएगा। निलंबित किया जा सकता है और नए हार्डवेयर पर फिर से शुरू किया जा सकता है)।

Comments

लानत है - तो शायद सर्वर थ्रेड्स बनाने वाले गाइड एक बेहतर विचार है?

— काई

क्वाड कोर प्रोसेसर पर 4 थ्रेड्स इसे ब्रह्माण्ड की उम्र के 20 बिलियन गुना तक चलाएंगे - इसलिए हाँ, इससे बहुत मदद मिलेगी।

— rjmunro

मुझे संदेह है कि यह एक ट्रोल है, लेकिन इस मौके पर कि यह नहीं है: धागे जादुई नहीं हैं। यदि आप एक थ्रेड पर प्रति सेकंड एक बिलियन ऑपरेशन कर सकते हैं, तो दस थ्रेड्स पर जाने का मतलब है कि प्रत्येक एक 1/10 वीं को अक्सर चलाता है। प्रत्येक थ्रेड प्रति सेकंड 100 एम ऑपरेशन करता है; संचालन की कुल संख्या प्रति सेकंड नहीं बढ़ी है। प्रति सेकंड संचालन की संख्या बढ़ाने का तरीका अधिक कंप्यूटर खरीदना है। मान लीजिए आपने एक बिलियन से अधिक कंप्यूटर खरीदे हैं। यह केवल 10790283070806 वर्षों तक समस्या को कम करेगा, जो अभी भी चार घंटे से अधिक है।

— एरिक लिपर्ट

मुझे लगता है कि rjmunro मान रहा है कि प्रत्येक धागा एक अलग कोर पर चलेगा; 83 बिलियन ब्रह्मांड / 4 कोर वास्तव में लगभग 20 बिलियन ब्रह्मांड के बराबर हैं। इंटेल स्टॉक खरीदने का समय!

— हाई आर्क

@ एरिक 83 बिलियन प्रोसेसर का मतलब है कि आप ब्रह्मांड के अब तक मौजूद रहने की मात्रा के बारे में कर पाएंगे। यहां तक ​​कि यह लगभग पर्याप्त नहीं है।

— rjmunro

Answer 3

एक GUID सैद्धांतिक रूप से गैर-अद्वितीय है। यहाँ आपका प्रमाण है:

• GUID एक 128 बिट नंबर है
• आप पुराने GUID का उपयोग किए बिना 2 ^ 128 + 1 या अधिक GUIDs उत्पन्न नहीं कर सकते

हालाँकि, अगर सूर्य के पूरे बिजली उत्पादन को इस कार्य को करने के लिए निर्देशित किया गया था, तो यह समाप्त होने से बहुत पहले ठंडा हो जाएगा।

कई अलग-अलग रणनीति का उपयोग करके GUID उत्पन्न किए जा सकते हैं, जिनमें से कुछ यह गारंटी देने के लिए विशेष उपाय करते हैं कि किसी दिए गए मशीन से एक ही GUID दो बार उत्पन्न नहीं होगा। एक विशेष एल्गोरिथ्म में टकराव खोजने से पता चलता है कि GUIDs बनाने के लिए आपका विशेष तरीका खराब है, लेकिन सामान्य रूप से GUID के बारे में कुछ भी साबित नहीं होगा।

Comments

बचाव के लिए कबूतरबाजी का सिद्धांत!

— yfeldblum

सूरज की ठंडी टिप्पणी के लिए +1। एन्क्रिप्शन कुंजी> 256 बिट्स की व्यर्थता के बारे में कहीं न कहीं एक दिलचस्प टिप्पणी थी। सभी संभावित प्रमुख मूल्यों पर पुनरावृत्ति करने के लिए संपूर्ण ब्रह्मांड की तुलना में अधिक ऊर्जा होगी। CPU में थोड़ा सा टॉगल करने के लिए थोड़ी मात्रा में ऊर्जा की आवश्यकता होती है (यह उष्मा उत्पन्न करता है), जो कि 2 ^ 256 गुणा होने पर वास्तव में बड़े पैमाने पर संख्या ब्रह्मांड में संग्रहीत ऊर्जा से अधिक हो जाती है, E = mc2 के उपयोग से ब्रह्मांड के द्रव्यमान की बड़े पैमाने पर आवश्यकता होती है 2 ^ 227kg, हमारा सूरज 2 ^ 101kg है इसलिए 2 ^ 126 सूरज!

— Skizz

@Skizz: यह केवल जानवर बल के हमलों के लिए सच है। जब एक एन्क्रिप्शन स्कीम "टूटी हुई" होती है, तो इसका मतलब है कि इसे कम समय में क्रूर बल से हल किया जा सकता है, लेकिन हल करने का समय मुख्य आकार के लिए आनुपातिक रहता है।

— स्टीवन सुदित

@StevenSudit: मुख्य आकार के घातांक के आनुपातिक (जब तक P == एनपी)

— इहर दफन

@Orlangur बिट्स में मापा जाने वाला कुंजी आकार का आनुपातिक।

— स्टीवन सुदित

Answer 4

बेशक GUIDs टकरा सकते हैं। चूंकि GUIDs 128-बिट्स हैं, बस 2^128 + 1उन्हें उत्पन्न करते हैं और कबूतर सिद्धांत द्वारा एक टकराव होना चाहिए।

लेकिन जब हम कहते हैं कि एक GUID एक अद्वितीय है, तो हम वास्तव में इसका मतलब यह है कि प्रमुख स्थान इतना बड़ा है कि गलती से दो बार एक ही GUID उत्पन्न करना व्यावहारिक रूप से असंभव है (यह मानते हुए कि हम बेतरतीब ढंग से GUID उत्पन्न कर रहे हैं)।

यदि आप nबेतरतीब ढंग से GUID का अनुक्रम उत्पन्न करते हैं , तो कम से कम एक टक्कर की संभावना लगभग होती है p(n) = 1 - exp(-n^2 / 2 * 2^128)(यह जन्मदिन की संभावित संख्या के साथ जन्मदिन की समस्या है2^128 )।

   n     p(n)
2^30 1.69e-21
2^40 1.77e-15
2^50 1.86e-10
2^60 1.95e-03

इन नंबरों ठोस बनाने के लिए, 2^60 = 1.15e+18। इसलिए, यदि आप प्रति सेकंड एक बिलियन GUID बनाते हैं, तो 2^60यादृच्छिक GUID को जनरेट करने में आपको 36 साल लगेंगे और तब भी आपके पास टक्कर होने की संभावना अभी भी है 1.95e-03। आप अगले 36 वर्षों में टकराव का पता लगाने के लिए अपने जीवन ( 4.76e-03) में कुछ बिंदु पर हत्या कर सकते हैं। सौभाग्य।

Comments

यदि आप अपने जीवन के किसी बिंदु पर हत्या कर रहे हैं, तो यह अंत में होगा।

— माइकल मायर्स

@ खरीदार: उत्कृष्ट बिंदु। इसका मतलब है कि अभी मेरी हत्या होने की संभावना बहुत कम है, क्योंकि यह मेरे जीवन का अंत नहीं है। ओह, रुको ...

— स्टीवन सुदित

इसके अलावा, यदि दो GUID एक छोटी अवधि के भीतर निर्मित होते हैं, तो वे एक ही प्रणाली के भीतर उपयोग किए जाने की संभावना थोड़ी है। इसलिए, यह विशिष्टता बढ़ाता है।

— एमीसिको

ये संख्या और जन्मदिन की समस्या के संदर्भ निरर्थक हैं। GUID पीढ़ी के एल्गोरिदम पूरे रेंज में समान संभावना वाले मान उत्पन्न नहीं करते हैं। वास्तव में IIRC मूल एल्गोरिथ्म ने परिणाम के भाग के रूप में उत्पन्न पीसी + के वर्तमान समय के मैक पते का उपयोग किया - जो अन्य पीसी पर उत्पन्न गिड्स के साथ टकराव के जोखिम को कम करता है, लेकिन निश्चित रूप से प्रमुख स्थान को कम करता है।

— जो

आप मान रहे हैं कि हत्या किए जाने की संभावना सभी मनुष्यों के लिए एक निरंतरता है। लेकिन स्पष्ट रूप से जो लोग फ़ोरम पोस्ट में स्नाइड टिप्पणी लिखते हैं, वे ऐसे लोग हैं जिनकी औसत व्यक्ति की तुलना में हत्या होने की अधिक संभावना है।

— जय

Answer 5

यदि आप विशिष्टता के बारे में चिंतित हैं तो आप हमेशा नए GUID खरीद सकते हैं ताकि आप अपने पुराने को निकाल सकें। अगर तुम चाहो तो मैं ईबे पर कुछ डाल दूँगा।

Comments

कूल - पूर्ण सेट के लिए कितना, 0 से (2 ^ 128) -1 तक?

— स्टीव ३४

बिक्री पर, $ 1 प्रति GUIDs 0.01 डॉलर। यदि आप अगले 60 मिनट में आदेश देते हैं तो मैं कुछ बांस की विंड चाइम्स में फेंक दूंगा।

— ctacke

मेरा सेट अधिक विशिष्ट और उच्च गुणवत्ता का है। वे दोहरी जाँच और सत्यापित हैं जो उन्हें $ 1 प्रति GUID के लायक बनाता है। यदि आप एक बार में पूरा निवेश नहीं करना चाहते हैं तो आप उन्हें बैचों में भी खरीद सकते हैं। मुझे हालांकि प्रति बैच 10 डॉलर अतिरिक्त शुल्क देना होगा।

— थॉमस

मैं आपको एक मासिक योजना पर स्थापित करूँगा और आपको सही कीमत के लिए असीमित मार्गदर्शक दूंगा। ^ वे लोग आपको घोटाला करने की कोशिश कर रहे हैं और आपको ओवरराइड गाइड बेच रहे हैं। मैं तुम्हें गुणवत्ता चीन में किए गए guids बेच देंगे!

— ErocM

Answer 6

व्यक्तिगत रूप से, मुझे लगता है कि "बिग बैंग" तब हुआ था जब दो GUID टकराए थे।

Comments

बस याद रखें कि ऐसा करने के लिए "विशेष" प्रकार का प्रोग्रामर लगता है ...

— एंथनीलैम्बर्ट

मैं आपके सिद्धांत को आपके तर्क को सुनना चाहूंगा। मुझे लगता है कि हम इस पर आधारित एक नया धर्म शुरू कर सकते हैं और T.Cruise की भर्ती कर सकते हैं!

— ErocM

@ErocM; "ब्रांज़ कॉस्मोलॉजी" ( en.wikipedia.org/wiki/Brane_cosmology ) और "मेम्ब्रेन (एम-थ्योरी)" ( en.wikipedia.org/wiki/Membrane_(M-ory) ) देखें। विचार यह है कि यदि दो शाखाएं एक नए ब्रह्मांड को स्पर्श करती हैं तो निर्मित होती है। इसलिए, आप अनुमान लगा सकते हैं कि यदि दो GUIDs स्पर्श करते हैं, तो एक नया ब्रह्मांड इस प्रकार बनाया जाता है।

— एमीसिको

अगर टिमकोप ने हमें कुछ भी सिखाया है तो वही मामला किसी भी समय एक ही स्थान पर कब्जा नहीं कर सकता है। इसलिए यदि दो GUIDs जहां टकराते हैं, तो वे एक-दूसरे का उपभोग करते हैं और परिणामस्वरूप निहित एक ब्लैक होल उत्पन्न होता है, जो पूरे ब्रह्मांड को प्रभावित करता है। तो वास्तव में, यह एक ब्रह्मांड नहीं बनायेगा, इसे नष्ट कर देगा।

— एजेसी

Answer 7

आप ओ (1) समय में क्वांटम बोगोसॉर्ट एल्गोरिथ्म के एक संस्करण के साथ दिखा सकते हैं ।

Guid g1 = Guid.NewGuid();
Guid g2 = Guid.NewGuid();
if(g1 != g2) Universe.Current.Destroy();

Comments

जब मैं नष्ट कर रहा हूँ () बुला रहा हूँ। पाठ के आधार पर, मुझे लगता है कि मेरे कंप्यूटर में वर्तमान ब्रह्मांड को नष्ट करने के लिए आवश्यक हार्डवेयर का अभाव है। क्या आप जानते हैं कि मैं इसे कहाँ प्राप्त कर सकता हूँ?

— स्टीवन सुदित

@ सीन: नाह, कुछ प्रबंधन के लोग इस बात से बहुत चिंतित थे कि एपीआई जनता के लिए कितना बुरा होगा, और इसे "सुरक्षा कारणों" के लिए हमेशा विफल रहने के लिए निर्धारित किया। यदि आप विधि के स्रोत को देखते हैं तो बस एक पंक्ति है throw new MundaneHardwareException();:। वैसे भी, मैंने सुना है कि CERN के लोग बिग हैड्रॉन थिंगी के कुछ प्रकार हैं जो शायद कर सकते हैं ...

— आर। मार्टिनो फर्नांडीस

@ मर्तिन्हो: आह, ठीक है। मैं के Universe.Current.Destroy()साथ जगह में देख लेंगे Cern.Lhc.DestroyThisUniverse()।

— स्टीवन सुदित

मुझे पता था कि एक कारण है कि मैंने हास्केल में प्रोग्राम किया था। ये दुष्प्रभाव डरावने हो रहे हैं।

— एडवर्ड KMETT

"एक सिद्धांत है जो बताता है कि अगर कभी किसी को कभी भी पता चलता है कि ब्रह्मांड क्या है और यह यहाँ क्यों है, तो यह तुरंत गायब हो जाएगा और इसे कुछ और भी विचित्र रूप से अकथनीय द्वारा प्रतिस्थापित किया जाएगा। एक और सिद्धांत है जिसमें कहा गया है कि यह पहले से ही हुआ है। । " - डगलस एडम्स, द हिचहाइकर गाइड टू द गैलेक्सी

— माइक पीरनेट

Answer 8

कोई भी दो GUID बहुत विशिष्ट होने की संभावना है (न के बराबर)।

इस SO प्रविष्टि को देखें , और विकिपीडिया से

जबकि प्रत्येक उत्पन्न GUID को विशिष्ट होने की गारंटी नहीं है, कुल कुंजियों की अद्वितीय संख्या (2 ^ 128 या 3.4 × 10 ^ 38) इतनी बड़ी है कि एक ही संख्या के दो बार उत्पन्न होने की संभावना बहुत कम है। उदाहरण के लिए, अवलोकन योग्य ब्रह्मांड पर विचार करें, जिसमें लगभग 5 × 10 ^ 22 सितारे हैं; प्रत्येक तारा तब 6.8 × 10 ^ 15 सार्वभौमिक अद्वितीय GUID हो सकता था।

तो शायद आपको कई और अरब वर्षों तक इंतजार करना होगा, और आशा है कि आप ब्रह्मांड से पहले एक हिट करेंगे क्योंकि हम जानते हैं कि यह समाप्त हो गया है।

Comments

तो 2 ^ 128 संभव गाइड की सही संख्या नहीं है?

— काई

यह है। आपको क्यों लगता है कि 2 ^ 128 एक छोटी संख्या है?

— 1

हां, 2 ^ 128 संभावित छापों की सही संख्या है।

— ग्रिटिटॉन

वह एक नंबर का नर्क है। $ irb >> 2**128 => 340282366920938463463374607431768211456

— adamJLev

@ इन्फिनिटी - यहां तक ​​कि आप के लिए?

— ऑस्टिन रिचर्डसन

Answer 9

[अद्यतन:] नीचे टिप्पणी के रूप में, नए एमएस GUIDs V4 हैं और GUID पीढ़ी के हिस्से के रूप में मैक पते का उपयोग नहीं करते हैं (मैंने एमएस से वी 5 के कार्यान्वयन का कोई संकेत नहीं देखा है, हालांकि, अगर किसी के पास है लिंक पुष्टि करता है कि मुझे बताएं)। हालांकि, V4 समय अभी भी एक कारक है, और GUIDs के दोहराव के खिलाफ बाधाओं को किसी भी व्यावहारिक उपयोग के लिए अप्रासंगिक होने के लिए इतना छोटा रहता है। आप निश्चित रूप से कभी भी एक एकल प्रणाली परीक्षण से डुप्लिकेट GUID उत्पन्न करने की संभावना नहीं होगी जैसे कि ओपी करने की कोशिश कर रहा था।

इनमें से अधिकांश उत्तर Microsoft के GUID कार्यान्वयन के बारे में एक महत्वपूर्ण बिंदु याद कर रहे हैं। GUID का पहला भाग टाइमस्टैम्प पर आधारित है और दूसरा भाग नेटवर्क कार्ड के MAC पते (या यदि NIC स्थापित नहीं है तो एक यादृच्छिक संख्या) पर आधारित है।

अगर मैं इसे सही ढंग से समझता हूं, तो इसका मतलब है कि एक GUID को डुप्लिकेट करने का एकमात्र विश्वसनीय तरीका कई मशीनों पर एक साथ GUID पीढ़ियों को चलाना होगा जहां मैक पते समान थे और जहां दोनों सिस्टम पर घड़ियों एक ही सटीक समय पर थीं जब पीढ़ी हुआ (टाइमस्टैम्प मिलीसेकंड पर आधारित है अगर मैं इसे सही ढंग से समझता हूं) .... तो भी संख्या में बहुत सारे अन्य बिट्स हैं जो यादृच्छिक हैं, इसलिए ऑड अभी भी गायब हैं।

सभी व्यावहारिक उद्देश्यों के लिए, GUIDs सार्वभौमिक रूप से अद्वितीय हैं।

"द न्यू न्यू थिंग" ब्लॉग पर MS GUID का बहुत अच्छा वर्णन है

Comments

वर्चुअलाइजेशन का उपयोग करते समय वास्तव में थॉट्स। आप कर सकते हैं और आप डुप्लिकेट छापे प्राप्त करते हैं।

— गोरान

रेमंड मैक एड्रेस हिस्से पर पुराना है, हालांकि, माइक्रोसॉफ्ट अब इनका उपयोग नहीं करता है। V1 और V4 गाइड के बीच अंतर के लिए en.wikipedia.org/wiki/GUID#Al एल्गोरिदम देखें ।

— माइकल Stum

यह अब मामला ही नहीं है। वर्तमान V5 योजना शुद्ध छद्म आयामी अच्छाई के सिर्फ 128 बिट्स है।

— एडवर्ड KMETT 14

अजीब बात है कि आप मेरे द्वारा किए गए एक महीने बाद सब कुछ बता देते हैं और आपको 16 अंक मिलते हैं और मेरे पास अभी भी 0 है?

— एंथनीलैम्बर्ट

हां टोनी, इसके साथ कुछ अजीब है। वापस जब मैंने पोस्ट का उत्तर दिया, तो केवल 3 या 4 उत्तर थे, और मुझे आपका यह देखना याद नहीं था ... अगर मेरे पास था, तो मैंने इसे रद्द कर दिया है। जब आम तौर पर पहले से ही इसे अच्छी तरह से कवर किया जाता है (तो यही कारण है कि मेरे पास कुल मिलाकर कम प्रतिनिधि है शायद इसलिए) मैं सवालों के जवाब नहीं देता।

— स्टीफन एम। रेड

Answer 10

यहां एक निफ्टी थोड़ा विस्तार विधि है जिसका उपयोग आप अपने कोड में कई स्थानों पर गाइड विशिष्टता की जांच करने के लिए कर सकते हैं।

internal static class GuidExt
{
    public static bool IsUnique(this Guid guid)
    {
        while (guid != Guid.NewGuid())
        { }
        return false;
    }
}

इसे कॉल करने के लिए, जब भी आप एक नई गाइड जेनरेट करते हैं, तो Guide.IsUnique पर कॉल करें ...

Guid g = Guid.NewGuid();
if (!g.IsUnique())
{
    throw new GuidIsNotUniqueException();
}

... बिल्ली, मैं यह भी दो बार यह सुनिश्चित करने की सलाह दूंगा कि यह पहले दौर में सही हो गया।

Comments

यह कैसे सुनिश्चित करता है कि this guidइस दुनिया में कहीं और उत्पन्न नहीं हुआ है? : पी हेक हमें एक विश्व गाइड पूल की आवश्यकता है। :)

— नवाफल

Answer 11

2 ^ 128 की गिनती - महत्वाकांक्षी।

आइए कल्पना करें कि हम प्रति मशीन प्रति 2 ^ 32 आईडी प्रति - गिनती कर सकते हैं - ऐसा नहीं है महत्वाकांक्षी , क्योंकि यह प्रति सेकंड 4.3 बिलियन भी नहीं है। उस कार्य को 2 ^ 32 मशीनें समर्पित करें। इसके अलावा, प्रत्येक को कार्य के लिए समान संसाधनों को समर्पित करने के लिए 2 ^ 32 सभ्यताएं मिलती हैं।

अब तक, हम 2 ^ 96 आईडी प्रति सेकंड की गणना कर सकते हैं, जिसका अर्थ है कि हम 2 ^ 32 सेकंड (136 साल से थोड़ा अधिक) के लिए गिनती करेंगे।

अब, हम सभी को 4,294,967,296 सभ्यताओं को प्रत्येक 4,294,967,296 मशीनों को समर्पित करने की आवश्यकता है, प्रत्येक मशीन 4,294,967,296 आईडी प्रति सेकंड की गिनती करने में सक्षम है, विशुद्ध रूप से अगले 136 वर्षों के लिए इस कार्य के लिए या तो - मेरा सुझाव है कि हम अभी इस आवश्यक कार्य पर आरंभ करें; -)

Answer 12

वैसे अगर if३ बिलियन वर्ष का रनिंग टाइम आपको डराता नहीं है, तो सोचें कि आपको यह भी जाँचने के लिए कि कहीं आपके पास कोई डुप्लिकेट है तो जनरेट किए गए GUID को स्टोर करने की आवश्यकता होगी; स्टोर करने के लिए 2 ^ 128 16-बाइट नंबर के लिए आपको केवल 495176015714152109959649696896 रैम अपफ्रंट की टेराबाइट्स आवंटित करने की आवश्यकता होगी, इसलिए कल्पना करना कि आपके पास एक ऐसा कंप्यूटर है जो सभी को फिट कर सकता है और यह कि आप किसी भी तरह से 10 ग्राम पर टेराबाइट डीआईएमएम खरीदने के लिए एक जगह पाते हैं, संयुक्त वे 8 से अधिक पृथ्वी द्रव्यमानों का वजन करें, ताकि आप "रन" दबाए जाने से पहले इसे गंभीरता से वर्तमान कक्षा में स्थानांतरित कर सकें। दो बार सोचो!

Answer 13

for(begin; begin<end; begin)
    Console.WriteLine(System.Guid.NewGuid().ToString());

आप वेतन वृद्धि नहीं कर रहे हैं beginइसलिए हालत begin < endहमेशा सही है।

Comments

कोई कारण नहीं है कि मैं bigint का उपयोग नहीं कर सकता

— काई

क्या यह वास्तव में मायने रखता है यदि वह हमेशा के लिए लूपिंग करता है बनाम लूपिंग 340282366920938463463374607431768211456 बार?

— जय

इसलिए ... क्या आप 340282366920938463463374607431768211456 बार या हमेशा के लिए मुक्का मारा जाएगा?!?!?

— ErocM

वास्तव में यह वही है जो वास्तव में सवाल का जवाब देता है! और कोई वोट बिल्कुल नहीं: पी

— नवाफ़ल

Answer 14

यदि GUID टकराव एक चिंता का विषय है, तो मैं इसके बजाय ScottGuID का उपयोग करने की सलाह दूंगा ।

Answer 15

संभवतः आपके पास यह विश्वास करने का कारण है कि गिड्स के निर्माण के लिए एल्गोरिथ्म वास्तव में यादृच्छिक संख्या का उत्पादन नहीं कर रहा है, लेकिन वास्तव में एक अवधि के साथ साइकिल चलाना है << 2 ^ 128।

उदाहरण के लिए RFC4122 विधि का उपयोग GUID को प्राप्त करने के लिए किया जाता है जो कुछ बिट्स के मूल्यों को ठीक करता है।

सायक्लिंग का प्रमाण अवधि के संभावित आकार पर निर्भर करता है।

छोटी अवधियों के लिए, हैश की हैश तालिका (GUID) -> GUID टकराव पर प्रतिस्थापन के साथ GUID यदि मिलान नहीं करते हैं (समाप्त करें तो वे करते हैं) एक दृष्टिकोण हो सकता है। केवल समय के एक यादृच्छिक अंश को बदलने पर विचार करें।

अंततः यदि टकरावों के बीच की अधिकतम अवधि काफी बड़ी है (और पहले से ज्ञात नहीं है) तो कोई भी विधि केवल एक संभावना पैदा करने वाली है कि टक्कर का अस्तित्व तब होगा जब वह मौजूद थी।

ध्यान दें कि यदि गिड्स बनाने की विधि घड़ी आधारित है (RFC देखें), तो यह निर्धारित करना संभव नहीं होगा कि क्या टक्कर मौजूद हैं क्योंकि या तो (क) आप घड़ी को गोल लपेटने के लिए लंबे समय तक इंतजार नहीं कर पाएंगे। या (बी) आप एक टक को मजबूर करने के लिए घड़ी की टिक के भीतर पर्याप्त गिड्स का अनुरोध नहीं कर सकते।

वैकल्पिक रूप से आप मार्गदर्शक में बिट्स के बीच एक सांख्यिकीय संबंध, या गाइड्स के बीच बिट्स के परस्पर संबंध को दिखाने में सक्षम हो सकते हैं। इस तरह के संबंध से यह अत्यधिक संभावना हो सकती है कि एल्गोरिथ्म बिना किसी वास्तविक टकराव को खोजने में सक्षम होने के बिना त्रुटिपूर्ण है।

बेशक, अगर आप सिर्फ यह साबित करना चाहते हैं कि गाइड्स टकरा सकते हैं, तो एक गणितीय प्रमाण, एक कार्यक्रम नहीं है, इसका जवाब है।

Answer 16

मुझे समझ में नहीं आता कि किसी ने आपके ग्राफिक्स कार्ड को अपग्रेड करने का उल्लेख क्यों नहीं किया है ... निश्चित रूप से अगर आपको एक उच्च-स्तरीय NVIDIA क्वाड्रो एफएक्स 4800 या कुछ (192 क्यूडा कोर) मिला है तो यह तेजी से आगे बढ़ेगा ...

बेशक अगर आप कुछ NVIDIA Qadro Plex 2200 S4s (960 CUDA कोर पर प्रत्येक) खरीद सकते हैं, तो यह गणना वास्तव में होगी चिल्लाएगी। शायद एक पीआर स्टंट के रूप में NVIDIA आपको "प्रौद्योगिकी प्रदर्शन" के लिए कुछ ऋण देने के लिए तैयार होगा?

निश्चित रूप से वे इस ऐतिहासिक गणना का हिस्सा बनना चाहते हैं ...

Comments

हम्म्म्म ..... मैं इसे काम पर हमारे 10,000 नोड ग्रिड पर चला सकता हूं।

— एंथनीलैम्बर्ट

Answer 17

लेकिन क्या आपको यह सुनिश्चित करना है कि आपके पास एक डुप्लिकेट है, या क्या आपको केवल एक डुप्लिकेट हो सकता है। यह सुनिश्चित करने के लिए कि आपके पास एक ही जन्मदिन वाले दो लोग हैं, आपको 366 लोगों की ज़रूरत है (लीप ईयर की गिनती नहीं)। एक ही जन्मदिन पर दो लोगों के होने की संभावना 50% से अधिक होने के लिए आपको केवल 23 लोगों की आवश्यकता है। वह जन्मदिन की समस्या है ।

यदि आपके पास 32 बिट्स हैं, तो आपको केवल डुप्लिकेट के 50% से अधिक होने के लिए 77,163 मानों की आवश्यकता है। कोशिश करके देखो:

Random baseRandom = new Random(0);

int DuplicateIntegerTest(int interations)
{
    Random r = new Random(baseRandom.Next());
    int[] ints = new int[interations];
    for (int i = 0; i < ints.Length; i++)
    {
        ints[i] = r.Next();
    }
    Array.Sort(ints);
    for (int i = 1; i < ints.Length; i++)
    {
        if (ints[i] == ints[i - 1])
            return 1;
    }
    return 0;
}

void DoTest()
{
    baseRandom = new Random(0);
    int count = 0;
    int duplicates = 0;
    for (int i = 0; i < 1000; i++)
    {
        count++;
        duplicates += DuplicateIntegerTest(77163);
    }
    Console.WriteLine("{0} iterations had {1} with duplicates", count, duplicates);
}

1000 iterations had 737 with duplicates

अब 128 बिट्स बहुत है, इसलिए आप अभी भी बड़ी संख्या में आइटमों पर बात कर रहे हैं जो आपको टक्कर का कम मौका दे रहे हैं। आपको सन्निकटन का उपयोग करते हुए दिए गए बाधाओं के लिए निम्नलिखित संख्याओं की आवश्यकता होगी:

• टकराव होने के 1/1000 मौके के लिए 0.8 बिलियन बिलियन
• टक्कर होने के 50% अवसर के लिए 21.7 बिलियन बिलियन
• टकराव की 90% संभावना के लिए 39.6 बिलियन बिलियन

प्रति वर्ष लगभग 1E14 ईमेल भेजे जाते हैं, इसलिए इस स्तर पर यह लगभग 400,000 वर्ष का होगा, इससे पहले कि आपके पास एक ही GUID के साथ दो होने का 90% मौका होगा, लेकिन यह कहना बहुत अलग है कि आपको 83 बिलियन कंप्यूटर चलाने की आवश्यकता है ब्रह्माण्ड की आयु या उस समय जब सूर्य डुप्लिकेट खोजने से पहले ठंडा हो जाएगा।

Answer 18

आप सभी एक प्रमुख बिंदु याद नहीं कर रहे हैं?

मैंने सोचा था कि GUID दो चीजों का उपयोग करके उत्पन्न हुए थे जो कि विश्व स्तर पर अद्वितीय होने की संभावनाएं काफी अधिक हैं। एक यह है कि वे मशीन के मैक पते के साथ हैं, जो आप चालू हैं और दो वे उस समय का उपयोग करते हैं जो वे उत्पन्न हुए थे और साथ ही एक यादृच्छिक संख्या।

इसलिए जब तक आप इसे वास्तविक मशीन पर नहीं चलाते हैं और आप सभी अनुमान लगाते हैं, तब तक यह अनुमान लगाया जाता है कि मशीन GUID में एक समय का प्रतिनिधित्व करने के लिए उपयोग करती है, आप कभी भी एक ही संख्या उत्पन्न नहीं करेंगे चाहे आप सिस्टम कॉल का उपयोग करके कितने अनुमान लगाते हों।

मुझे लगता है कि अगर आप जानते हैं कि जिस तरह से एक GUID बनाया गया है वह वास्तव में काफी हद तक अनुमान लगाने के लिए समय कम कर देगा।

टोनी

Comments

सभी GUID इस तरह से नहीं बनाए जाते हैं। यहां तक ​​कि अगर वे थे, तो काई को केवल तब तक इंतजार करना पड़ता है जब तक कि टाइमस्टैम्प का उपयोग GUID के चारों ओर पर्याप्त समय के लिए नहीं किया जाता है जब तक कि वह एक GUID बनाने के लिए उपयोग किया जाता है फिर से उपयोग किया जाता है।

— डोर हाई आर्क

2000 या 2001 के बाद से मैक पते पर आधारित नहीं हैं। NT4 और / या Win2k के सर्विस पैक में से एक के रूप में उन्होंने एल्गोरिथ्म को पूरी तरह से बदल दिया है। वे अब एक यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न होते हैं, कुछ बिट्स को घटाते हैं जो पहचानते हैं कि यह किस प्रकार का मार्गदर्शक है।

— क्रिस्टोफ़रए

सभी

— GUID

ओपी C # का उल्लेख करता है, इसलिए यह विंडोज है। इसके अलावा, V4 GUID एक Windows- केवल एक चीज है?

— स्टीवन सुदित

@Martinho: आह, लेकिन गाइडटैस्ट में गाइड के लिए मोनो की इकाई परीक्षण में एक विधि शामिल है, जो दो नए GUID बनाती है और समानता के लिए उन्हें जांचती है, यदि वे समान हैं तो विफल। जैसा कि मोनो सफलतापूर्वक बनाता है, हम पूरी तरह से निश्चित हो सकते हैं कि इसके GUID अद्वितीय हैं! :-)

— स्टीवन सुदित

Answer 19

आप GUID कर सकते हैं। इस तरह, आपको बहुत तेजी से परिणाम प्राप्त करना चाहिए।

ओह, निश्चित रूप से, एक ही समय में कई थ्रेड्स चलाना भी एक अच्छा विचार है, इस तरह आप दौड़ की स्थिति को अलग-अलग थ्रेड्स पर दो बार एक ही GUID बनाने की संभावना को बढ़ाएंगे।

Answer 20

GUIDs 124 बिट्स हैं क्योंकि 4 बिट्स वर्जन नंबर रखती हैं।

Comments

इसे टिप्पणी के रूप में न जोड़ने का कारण: किसी ने भी इसका उल्लेख नहीं किया, और मुझे नहीं पता कि मुझे यह किसे बताना चाहिए। :)

— बेहरोज

हुओराएए मैंने ऐसा किया। कुछ "वास्तविक" ऐप में मैंने लिखा, मुझे ~ 260k पंक्तियों वाली तालिका में एक गाइड की टक्कर मिली। (MSSQL 2008 R2 एक्सप्रेस)।

— बेहरोज़

Answer 21

1. न्यूयॉर्क शहर में क्रायोजेनिक्स प्रयोगशाला में जाएं।
2. अपने आप को फ्रीज करें (मोटे तौर पर) 1990 साल।
3. प्लैनेट एक्सप्रेस में नौकरी करें।
4. एक नया CPU खरीदें। एक कंप्यूटर बनाएं, प्रोग्राम को चलाएं, और इसे एक सुरक्षित स्थान पर एक छद्म क्रमिक गति मशीन जैसे प्रलयकाल मशीन के साथ रखें।
5. समय मशीन का आविष्कार होने तक प्रतीक्षा करें।
6. टाइम मशीन का उपयोग कर भविष्य के लिए कूदो। यदि आपने 1YHz 128bit सीपीयू खरीदा है, तो पर जाएं3,938,453,320 days 20 hours 15 minutes 38 seconds 463 ms 463 μs 374 ns 607 ps तो उस समय के बाद जाएं जब आपने प्रोग्राम चलाना शुरू किया था।
7. ...?
8. फायदा!!!

... 10,783,127अगर आपको 1YHz CPU है जो 1,000,000,000,000,000(या) है तो भी कम से कम साल लगेंगे1,125,899,906,842,624 आप द्विआधारी उपसर्ग का उपयोग करना पसंद करते हैं) गुना तेजी से 1GHz सीपीयू से।

इसलिए गणना समाप्त होने की प्रतीक्षा करने के बजाय, कबूतरों को खिलाने के लिए बेहतर होगा जो अपने घर को खो दिया क्योंकि अन्य n कबूतर अपने घर ले गए हैं। :(

या, आप 128-बिट क्वांटम कंप्यूटर का आविष्कार होने तक इंतजार कर सकते हैं। तब आप उचित समय (शायद) में अपने कार्यक्रम का उपयोग करके यह साबित कर सकते हैं कि GUID अद्वितीय नहीं है।

Comments

मैं इस जवाब में एक सुपर हीरो संदर्भ की प्रतीक्षा कर रहा था - पोस्टर द्वारा विफल: पी - भयानक कोई भी कम नहीं।

— IbrarMumtaz

Answer 22

क्या आपने begin = begin + new BigInteger((long)1)शुरुआत ++ के स्थान पर करने की कोशिश की है?

Comments

किसी ने उस उत्तर के लिए मतदान नहीं किया है जो वास्तव में इस सवाल का जवाब देता है: P

— nawfal

Answer 23

यदि यूयूआईडी की संख्या उत्पन्न की जा रही है तो मूर के नियम का पालन किया जाता है, भविष्य के भविष्य में GUID से बाहर नहीं निकलने की धारणा गलत है।

2 ^ 128 यूयूआईडी के साथ, हम सभी यूयूआईडी से बाहर निकलने से पहले केवल 18 महीने * लॉग 2 (2 ^ 128) ~ = 192 साल लगेंगे।

और मेरा मानना ​​है कि पिछले कुछ वर्षों में UUID के व्यापक रूप से गोद लेने के बाद (कोई-कोई सांख्यिकीय प्रमाण क्या-क्या है), हम जिस गति से UUID का निर्माण कर रहे हैं, वह मूर के कानून से अधिक तेजी से बढ़ रहा है। दूसरे शब्दों में, हमारे पास यूयूआईडी संकट से निपटने के लिए शायद 192 साल से कम का समय है, यह ब्रह्मांड के अंत की तुलना में बहुत जल्द है।

लेकिन जब से हम निश्चित रूप से 2012 के अंत तक उन्हें बाहर नहीं करेंगे, हम समस्या के बारे में चिंता करने के लिए इसे अन्य प्रजातियों के लिए छोड़ देंगे।

Answer 24

GUID जनरेटिंग कोड में एक बग की संभावना एक टकराव उत्पन्न करने वाले एल्गोरिदम की बाधाओं से बहुत अधिक है। GUID का परीक्षण करने के लिए आपके कोड में एक बग की संभावना और भी अधिक है। छोड़ दो।

Answer 25

कार्यक्रम, इसकी त्रुटियों के बावजूद, यह दर्शाता है कि एक GUID अद्वितीय नहीं है। जो लोग इसके विपरीत साबित होने की कोशिश करते हैं वे बिंदु को याद नहीं कर रहे हैं। यह कथन बस कुछ GUID विविधताओं के कमजोर कार्यान्वयन को प्रमाणित करता है।

एक GUID परिभाषा के हिसाब से आवश्यक नहीं है, यह परिभाषा के हिसाब से बेहद अनूठा है। आपने केवल अत्यधिक के अर्थ को परिष्कृत किया। संस्करण के आधार पर, कार्यान्वयनकर्ता (एमएस या अन्य), वीएम का उपयोग, आदि आपकी अत्यधिक परिवर्तनों की परिभाषा। (पहले की पोस्ट में लिंक देखें)

अपनी बात को साबित करने के लिए आप अपनी 128 बिट टेबल को छोटा कर सकते हैं। सबसे अच्छा समाधान यह है कि डुप्लिकेट के साथ अपनी तालिका को छोटा करने के लिए एक हैश सूत्र का उपयोग करें, और फिर एक बार हैश के टकराने और उस पर आधारित GUID को फिर से बनाने के लिए पूर्ण मान का उपयोग करें। यदि विभिन्न स्थानों से चल रहे हैं, तो आप अपने हैश / पूर्ण कुंजी जोड़े को एक केंद्रीय स्थान पर संग्रहीत करेंगे।

Ps: यदि लक्ष्य केवल x संख्या विभिन्न मान उत्पन्न करने के लिए है, तो इस चौड़ाई की हैश तालिका बनाएँ और हैश मान पर जाँच करें।

Answer 26

यहां अलाव पर पी ** एस नहीं, लेकिन यह वास्तव में होता है, और हां, मैं समझता हूं कि आप इस आदमी को दे रहे हैं मजाक कर रहे हैं, लेकिन GUID केवल सिद्धांत में अद्वितीय है, मैं इस धागे में टकरा गया क्योंकि एक बग है WP7 एमुलेटर में इसका मतलब है कि हर बार जब यह बूट होता है तो यह पहली बार SAME GUID को देता है! इसलिए, जहां सिद्धांत में आपके लिए कोई संघर्ष नहीं हो सकता है, अगर कोई समस्या है जो GUI कहा जाता है, तो आप डुप्लिकेट प्राप्त कर सकते हैं

http://forums.create.msdn.com/forums/p/92086/597310.aspx#597310

Answer 27

चूंकि गाइड जनरेशन का हिस्सा वर्तमान मशीन के समय पर आधारित है, इसलिए डुप्लिकेट गाइड पाने के लिए मेरा सिद्धांत है:

1. विंडोज की एक साफ स्थापना करें
2. एक स्टार्टअप स्क्रिप्ट बनाएं जो 2010-01-01 12:00:00 तक के समय को विंडोज बूट के रूप में रीसेट करता है।
3. स्टार्टअप स्क्रिप्ट के ठीक बाद, यह आपके एप्लिकेशन को एक गाइड जेनरेट करने के लिए ट्रिगर करता है।
4. इस विंडोज इंस्टॉलेशन को क्लोन करें, ताकि आप बाद के बूट-अप में होने वाले किसी भी सूक्ष्म अंतर को नियंत्रित कर सकें।
5. इस छवि के साथ हार्ड ड्राइव को फिर से छवि दें और मशीन को कुछ समय बूट करें।

Answer 28

मेरे लिए .. UUIDv1 गारंटी जनरेट करने के लिए सिंगल कोर के लिए जो समय लगता है वह अद्वितीय होगा। यहां तक ​​कि एक मल्टी कोर स्थिति में भी यदि यूयूआईडी जनरेटर केवल एक यूयूआईडी को आपके विशिष्ट संसाधन के लिए एक समय में उत्पन्न करने की अनुमति देता है (ध्यान रखें कि कई संसाधन पूरी तरह से उसी यूयूआईडी का उपयोग कर सकते हैं, हालांकि संसाधन स्वाभाविक रूप से पते का हिस्सा नहीं हैं) टाइमस्टैम्प के जलने तक आपके पास रहने के लिए पर्याप्त UUIDs होंगे। किस बिंदु पर मुझे वास्तव में संदेह है कि आप परवाह करेंगे।

Answer 29

यहाँ एक समाधान है:

int main()
{
  QUuid uuid;
  while ( (uuid = QUuid::createUuid()) != QUuid::createUuid() ) { }
  std::cout << "Aha! I've found one! " << qPrintable( uuid.toString() ) << std::endl;
}

नोट: क्यूटी की आवश्यकता है, लेकिन मैं गारंटी देता हूं कि यदि आप इसे लंबे समय तक चलने देते हैं, तो यह एक मिल सकता है।

(नोट नोट: वास्तव में, अब जब मैं इसे देख रहा हूं, तो पीढ़ी के एल्गोरिथ्म के बारे में कुछ हो सकता है जो बाद में उत्पन्न होने वाले दो uuids को टकराने से रोकता है - लेकिन मुझे इस पर संदेह है)।

Answer 30

GUIDs को साबित करने के लिए एकमात्र समाधान विश्व GUID पूल होने से अद्वितीय नहीं होगा। हर बार जब कोई GUID कहीं उत्पन्न होता है, तो उसे संगठन में पंजीकृत होना चाहिए। या बिल्ली, हम एक मानकीकरण शामिल कर सकते हैं कि सभी GUID जनरेटर को इसे स्वचालित रूप से पंजीकृत करने की आवश्यकता है और इसके लिए इसे एक सक्रिय इंटरनेट कनेक्शन की आवश्यकता है!