หลักฐานง่าย ๆ ที่ GUID นั้นไม่เหมือนใคร [ปิด]

ฉันต้องการพิสูจน์ว่า 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 #

ฉันได้จัดทำโปรแกรมที่จะทำสิ่งที่คุณต้องการโดยใช้เธรด มันได้รับอนุญาตภายใต้เงื่อนไขดังต่อไปนี้: คุณต้องจ่ายให้ฉัน $ 0.0001 ต่อชั่วโมงต่อ CPU หลักที่คุณใช้งาน ชำระค่าธรรมเนียมเมื่อสิ้นสุดแต่ละเดือนตามปฏิทิน โปรดติดต่อฉันสำหรับรายละเอียดบัญชี paypal ของฉันโดยเร็วที่สุด

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?");
        }
    }
}

PS: ฉันต้องการลองใช้ไลบรารีส่วนขยายแบบขนาน นั่นเป็นเรื่องง่าย

และใช้ OutOfMemoryException เป็นโฟลว์ควบคุมเพียงแค่รู้สึกผิด

แก้ไข

ดูเหมือนว่านี่จะยังคงดึงดูดคะแนนเสียง ดังนั้นฉันจึงแก้ไขปัญหา GC.KeepAlive () และเปลี่ยนมันให้ทำงานด้วย C # 4

และเพื่อชี้แจงข้อกำหนดการสนับสนุนของฉัน: การสนับสนุนมีให้เฉพาะใน 28 / Feb / 2010 โปรดใช้ไทม์แมชชีนเพื่อขอการสนับสนุนในวันนั้นเท่านั้น

แก้ไข 2 เช่นเคย GC ทำงานได้ดีกว่าการจัดการหน่วยความจำ ความพยายามครั้งก่อน ๆ ที่ทำด้วยตัวเองถูกทำให้ล้มเหลว

สิ่งนี้จะทำงานนานกว่าชั่วโมง สมมติว่ามันวนซ้ำที่ 1 GHz (ซึ่งมันจะไม่ - มันจะช้ากว่านั้นมาก) มันจะทำงานได้ 10790283070806014188970 ปี ซึ่งยาวกว่าอายุของจักรวาลประมาณ 83 พันล้านเท่า

สมมติว่ากฎหมายของมัวเรสถือเอาไว้มันจะเร็วกว่ามากหากไม่เรียกใช้โปรแกรมนี้รอหลายร้อยปีและเรียกใช้บนคอมพิวเตอร์ที่เร็วกว่าเป็นพันล้านครั้ง ในความเป็นจริงโปรแกรมใด ๆ ที่ใช้เวลานานกว่าที่ใช้ในการเพิ่มความเร็วของ CPU เป็นสองเท่า (ประมาณ 18 เดือน) จะเสร็จสมบูรณ์เร็วกว่านี้หากคุณรอจนกว่าความเร็วของ CPU จะเพิ่มขึ้นและซื้อ CPU ใหม่ก่อนที่จะเรียกใช้ สามารถถูกระงับและทำงานต่อบนฮาร์ดแวร์ใหม่)

GUID นั้นไม่เหมือนกันในทางทฤษฎี นี่คือหลักฐานของคุณ:

• GUID เป็นหมายเลข 128 บิต
• คุณไม่สามารถสร้าง 2 ^ 128 + 1 หรือมากกว่า GUID ได้โดยไม่ต้องใช้ GUID เก่าอีกครั้ง

อย่างไรก็ตามหากการส่งออกพลังงานทั้งหมดของดวงอาทิตย์มุ่งไปที่การทำงานนี้มันจะเย็นลงก่อนที่มันจะเสร็จสิ้น

สามารถสร้าง GUID ได้โดยใช้กลวิธีที่แตกต่างกันจำนวนหนึ่งซึ่งใช้มาตรการพิเศษเพื่อรับประกันว่าเครื่องที่กำหนดจะไม่สร้าง GUID เดียวกันสองครั้ง การค้นหาการชนในอัลกอริทึมเฉพาะจะแสดงให้เห็นว่าวิธีเฉพาะของคุณในการสร้าง GUID นั้นไม่ดี แต่จะไม่พิสูจน์อะไรเกี่ยวกับ GUID โดยทั่วไป

แน่นอน GUID สามารถปะทะกันได้ เนื่องจาก GUID นั้นมีขนาด 128 บิตเพียงแค่สร้าง2^128 + 1มันขึ้นมาและตามหลักการของช่องพิราบจึงต้องมีการชนกัน

แต่เมื่อเราพูดว่า GUID นั้นเป็นสิ่งที่ไม่ซ้ำกันสิ่งที่เราหมายถึงจริงๆคือพื้นที่สำคัญนั้นใหญ่มากจนไม่สามารถสร้าง GUID เดียวกันได้โดยบังเอิญสองครั้ง (สมมติว่าเรากำลังสร้าง GUID แบบสุ่ม)

หากคุณสร้างลำดับของnGUID แบบสุ่มความน่าจะเป็นของการชนอย่างน้อยหนึ่งครั้งจะอยู่ที่ประมาณ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 ของต่อวินาทีก็จะนำคุณ 36 ปีในการสร้าง2^60guid 1.95e-03ของสุ่มและแม้แล้วน่าจะเป็นที่คุณมีการปะทะกันยังคงเป็น คุณมีแนวโน้มที่จะถูกสังหารในบางจุดในชีวิตของคุณ ( 4.76e-03) มากกว่าที่คุณจะพบการปะทะกันในอีก 36 ปีข้างหน้า โชคดี.

หากคุณกังวลเกี่ยวกับความเป็นเอกลักษณ์คุณสามารถซื้อ GUID ใหม่ได้ตลอดเวลาเพื่อที่คุณจะได้ทิ้งของเก่าไป ฉันจะวางบนอีเบย์ถ้าคุณต้องการ

โดยส่วนตัวแล้วฉันคิดว่า "บิ๊กแบง" นั้นเกิดขึ้นเมื่อ GUID สองรายการชนกัน

คุณสามารถแสดงให้เห็นว่าในเวลา O (1) ด้วยตัวแปรของอัลกอริทึมbogosort ควอนตัม

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

GUID สองอันใด ๆ นั้นมีความเป็นเอกลักษณ์มาก (ไม่เท่ากัน)

ดูรายการ SO นี้และจากWikipedia

ในขณะที่แต่ละ GUID ที่สร้างขึ้นไม่ได้รับประกันว่าจะไม่ซ้ำกันจำนวนรวมของคีย์ที่ไม่ซ้ำกัน (2 ^ 128 หรือ 3.4 × 10 ^ 38) มีขนาดใหญ่มากจนความน่าจะเป็นของหมายเลขเดียวกันจะถูกสร้างขึ้นสองครั้ง ตัวอย่างเช่นลองพิจารณาเอกภพที่สังเกตได้ซึ่งมีดาวประมาณ 5 × 10 ^ 22 ดาว จากนั้นดาวทุกดวงจะมี GUID ที่เป็นเอกลักษณ์ในระดับสากล 6.8 × 10 ^ 15

ดังนั้นคุณอาจต้องรออีกหลายพันล้านปีและหวังว่าคุณจะตีหนึ่งต่อหน้าจักรวาลอย่างที่เรารู้ว่ามันจบลงแล้ว

[Update:] เนื่องจากความคิดเห็นด้านล่างชี้ให้เห็น MS GUID ที่ใหม่กว่าคือ V4 และไม่ใช้ที่อยู่ MAC เป็นส่วนหนึ่งของการสร้าง GUID (ฉันไม่เคยเห็นการใช้งาน V5 จาก MS เลยดังนั้นถ้าใครมี ลิงค์ยืนยันที่แจ้งให้เราทราบ) แม้ว่า V4 นั้นเวลาจะยังคงเป็นปัจจัยและโอกาสในการต่อต้านการซ้ำซ้อนของ GUIDs ยังคงมีขนาดเล็กมากจนไม่เกี่ยวข้องกับการใช้งานจริงใด ๆ แน่นอนว่าคุณไม่น่าจะสร้าง GUID ที่ซ้ำกันจากการทดสอบระบบเพียงครั้งเดียวเช่น OP กำลังพยายามทำ

คำตอบส่วนใหญ่จะหายไปหนึ่งจุดสำคัญเกี่ยวกับการใช้งาน GUID ของ Microsoft ส่วนแรกของ GUID ขึ้นอยู่กับการประทับเวลาและอีกส่วนหนึ่งขึ้นอยู่กับที่อยู่ MAC ของการ์ดเครือข่าย (หรือหมายเลขสุ่มหากไม่มีการติดตั้ง NIC)

ถ้าฉันเข้าใจสิ่งนี้อย่างถูกต้องก็หมายความว่าวิธีเดียวที่เชื่อถือได้ในการทำสำเนา GUID นั้นคือการเรียกใช้การสร้าง GUID แบบพร้อมกันบนเครื่องหลายเครื่องที่ที่อยู่ MAC เหมือนกันและที่นาฬิกาบนระบบทั้งสองอยู่ในเวลาเดียวกัน เกิดขึ้น (การประทับเวลาจะขึ้นอยู่กับมิลลิวินาทีถ้าฉันเข้าใจถูกต้อง) .... ถึงแม้จะมีบิตอื่น ๆ จำนวนมากในจำนวนที่เป็นแบบสุ่มดังนั้นอัตราต่อรองยังคงมีขนาดเล็กหายไป

เพื่อวัตถุประสงค์ในทางปฏิบัติทั้งหมด GUID นั้นมีความเป็นเอกลักษณ์ในระดับสากล

มีคำอธิบายที่ดีเกี่ยวกับ MS GUID ที่บล็อก "The Old New Thing"

นี่คือวิธีการขยายเล็กน้อยที่คุณสามารถใช้ถ้าคุณต้องการตรวจสอบความเป็นเอกลักษณ์ของ guid ในหลาย ๆ ที่ในรหัสของคุณ

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

หากต้องการเรียกมันเพียงเรียก Guid.IsUnique เมื่อใดก็ตามที่คุณสร้าง guid ใหม่ ...

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

... เฮ้ฉันขอแนะนำให้เรียกมันสองครั้งเพื่อให้แน่ใจว่ามันถูกต้องในรอบแรก

นับเป็น 2 ^ 128 - ทะเยอทะยาน

สมมติว่าเราสามารถนับ 2 ^ 32 IDs ต่อวินาทีต่อเครื่อง - ไม่ใช่ นั้นท้าทายเพราะมันไม่ใช่แม้กระทั่ง 4.3 พันล้านต่อวินาที ให้อุทิศเครื่อง 2 ^ 32 ให้กับงานนั้น นอกจากนี้ให้รับอารยธรรม 2 ^ 32 เพื่ออุทิศทรัพยากรเดียวกันให้กับงาน

จนถึงตอนนี้เราสามารถนับ 2 ^ 96 IDs ต่อวินาทีซึ่งหมายความว่าเราจะนับเป็น 2 ^ 32 วินาที (น้อยกว่า 136 ปี)

ตอนนี้ทั้งหมดที่เราต้องการคือการได้รับอารยธรรม 4,294,967,296 เครื่องต่อเครื่องอุทิศ 4,294,967,296 เครื่องแต่ละเครื่องสามารถนับ 4,294,967,296 IDs ต่อวินาทีได้อย่างแท้จริงสำหรับงานนี้ในอีก 136 ปีข้างหน้าหรืออย่างนั้น -)

ถ้าเวลาที่ใช้ไป 83 พันล้านปีไม่ทำให้คุณกลัวคิดว่าคุณจะต้องเก็บ GUID ที่สร้างขึ้นเพื่อตรวจสอบว่าคุณมีสิ่งที่ซ้ำกันหรือไม่ การจัดเก็บหมายเลข 2 ^ 128 16- ไบต์จะทำให้คุณต้องจัดสรร 4951760157141521099596496896 เทราไบต์ของล่วงหน้าจำนวน 4951760157141521099596966896 เทราไบต์ดังนั้นจินตนาการว่าคุณมีคอมพิวเตอร์ที่เหมาะสมกับทุกอย่างและคุณจะหาที่ที่จะซื้อเทราไบต์ทีละ 10 กรัมรวมกัน มีน้ำหนักมากกว่า 8 มวลโลกดังนั้นคุณจึงสามารถเปลี่ยนออกจากวงโคจรปัจจุบันอย่างจริงจังก่อนที่คุณจะกด "Run" คิดสองครั้ง!

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

คุณไม่ได้เพิ่มขึ้นbeginดังนั้นเงื่อนไขbegin < endจะเป็นจริงเสมอ

หากการชน GUID เป็นปัญหาฉันขอแนะนำให้ใช้ScottGuIDแทน

สันนิษฐานว่าคุณมีเหตุผลที่จะเชื่อได้ว่าอัลกอริทึมสำหรับการผลิต Guids นั้นไม่ได้สร้างตัวเลขสุ่มอย่างแท้จริง

เช่นวิธี RFC4122 ใช้ในการรับ GUID ซึ่งแก้ไขค่าของบิตบางส่วน

หลักฐานการปั่นจักรยานจะขึ้นอยู่กับขนาดของช่วงเวลาที่เป็นไปได้

สำหรับช่วงเวลาเล็ก ๆ ตารางแฮชของแฮช (GUID) -> GUID โดยแทนที่การชนถ้า GUID ไม่ตรงกัน (ยุติถ้าทำ) อาจเป็นแนวทาง ลองพิจารณาการเปลี่ยนเพียงเสี้ยวเวลาแบบสุ่มเท่านั้น

ในที่สุดหากระยะเวลาสูงสุดระหว่างการชนมีขนาดใหญ่พอ (และไม่ทราบล่วงหน้า) วิธีการใด ๆ ที่จะทำให้เกิดความน่าจะเป็นที่การชนจะพบได้หากมีอยู่

โปรดทราบว่าหากวิธีการสร้าง Guids นั้นเป็นแบบนาฬิกา (ดู RFC) ดังนั้นจึงเป็นไปไม่ได้ที่จะตัดสินว่ามีการชนกันอยู่หรือไม่เพราะ (a) คุณจะไม่สามารถรอได้นานพอที่นาฬิกาจะล้อมรอบ หรือ (b) คุณไม่สามารถร้องขอ Guids ได้มากพอภายในขีดนาฬิกาเพื่อบังคับให้เกิดการชน

หรือคุณอาจสามารถแสดงความสัมพันธ์ทางสถิติระหว่างบิตใน Guid หรือสหสัมพันธ์ของบิตระหว่าง Guids ความสัมพันธ์ดังกล่าวอาจทำให้มีความเป็นไปได้สูงที่อัลกอริทึมจะมีข้อบกพร่องโดยไม่จำเป็นต้องพบการชนจริง

แน่นอนถ้าคุณต้องการพิสูจน์ว่า Guids สามารถชนกันได้หลักฐานทางคณิตศาสตร์ไม่ใช่โปรแกรมเป็นคำตอบ

ฉันไม่เข้าใจว่าทำไมไม่มีใครพูดถึงการอัพเกรดกราฟิกการ์ดของคุณ ... แน่นอนถ้าคุณมี NVIDIA Quadro FX 4800 หรืออะไรซักอย่าง (192 CUDA แกน) สิ่งนี้จะเร็วขึ้น ...

แน่นอนถ้าคุณสามารถซื้อ NVIDIA Qadro Plex 2200 S4s ได้ (ที่ 960 CUDA แต่ละแกน) การคำนวณนี้จะเป็นจริงกรีดร้องๆ บางที NVIDIA อาจยินดีที่จะให้คุณยืม "การสาธิตเทคโนโลยี" ในฐานะการแสดงความสามารถด้านการประชาสัมพันธ์

แน่นอนว่าพวกเขาต้องการเป็นส่วนหนึ่งของการคำนวณทางประวัติศาสตร์นี้...

แต่คุณต้องให้แน่ใจว่าคุณมีซ้ำกันหรือไม่หรือคุณเพียงดูแลถ้ามีสามารถเป็นซ้ำ เพื่อให้แน่ใจว่าคุณมีสองคนที่มีวันเกิดเดียวกันคุณต้องการ 366 คน (ไม่นับปีอธิกสุรทิน) เพื่อที่จะมีโอกาสมากกว่า 50% ในการมีสองคนที่มีวันคล้ายวันเกิดคุณเพียง 23 คนเท่านั้น นั่นเป็นปัญหาวันเกิด

หากคุณมี 32 บิตคุณจะต้องมีค่า 77,163 ค่าเพื่อให้ได้โอกาสซ้ำซ้อนมากกว่า 50% ลองดูสิ:

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 บิตมีจำนวนมากดังนั้นคุณยังคงพูดถึงรายการจำนวนมากที่ยังคงให้โอกาสคุณชนน้อย คุณจะต้องมีจำนวนระเบียนต่อไปนี้สำหรับอัตราต่อรองที่กำหนดโดยใช้การประมาณ:

• 0.8 พันล้านพันล้านในโอกาส 1/1000 ของการชนที่เกิดขึ้น
• 21.7 พันล้านพันล้านสำหรับโอกาส 50% ของการชนที่เกิดขึ้น
• 39.6 พันล้านพันล้านสำหรับโอกาส 90% ของการชนที่เกิดขึ้น

มีอีเมลทั้งหมดประมาณ 1E14 ฉบับต่อปีดังนั้นมันจะอยู่ที่ประมาณ 400,000 ปีในระดับนี้ก่อนที่คุณจะมีโอกาส 90% ที่จะมีสองครั้งที่มี GUID เดียวกัน แต่แตกต่างจากการพูดว่าคุณต้องใช้คอมพิวเตอร์ 83 พันล้าน คูณด้วยอายุของเอกภพหรือว่าดวงอาทิตย์จะเย็นลงก่อนที่จะพบสิ่งที่ซ้ำกัน

คุณไม่ได้พลาดประเด็นสำคัญหรือ

ฉันคิดว่า GUID นั้นถูกสร้างขึ้นโดยใช้สองสิ่งซึ่งทำให้โอกาสที่พวกเขาจะมีความโดดเด่นในระดับโลกค่อนข้างสูง หนึ่งคือพวกเขาจะ seeded กับที่อยู่ MAC ของเครื่องที่คุณอยู่และสองพวกเขาใช้เวลาที่พวกเขาถูกสร้างขึ้นพร้อมตัวเลขสุ่ม

ดังนั้นหากคุณใช้งานบนเครื่องจริงและเรียกใช้ทั้งหมดที่คุณคาดเดาภายในเวลาที่น้อยที่สุดที่เครื่องใช้เพื่อแสดงเวลาใน GUID คุณจะไม่สร้างหมายเลขเดียวกันไม่ว่าคุณจะคาดเดาจำนวนเท่าใดโดยใช้การเรียกระบบ

ฉันเดาว่าถ้าคุณรู้วิธีที่แท้จริงของ GUID นั้นจะทำให้เวลาในการเดาค่อนข้างสั้นลงอย่างมาก

โทนี่

คุณสามารถแฮ่ GUID ได้ ด้วยวิธีนี้คุณควรได้ผลลัพธ์เร็วกว่ามาก

โอ้แน่นอนว่าการรันหลาย ๆ เธรดในเวลาเดียวกันก็เป็นความคิดที่ดีเช่นกันคุณจะเพิ่มโอกาสของสภาวะการแข่งขันที่สร้าง GUID เดียวกันสองครั้งในเธรดที่ต่างกัน

GUID เป็น 124 บิตเนื่องจาก 4 บิตถือหมายเลขรุ่น

1. ไปที่แล็บไครโอนิคส์ในนิวยอร์ก
2. ตรึงตัวเองเป็นเวลาประมาณปี 1990
3. รับงานที่ Planet Express
4. ซื้อ CPU ใหม่ สร้างคอมพิวเตอร์เรียกใช้โปรแกรมและวางไว้ในที่ปลอดภัยด้วยเครื่องเคลื่อนไหวหลอกตลอดเวลาเช่นเครื่องวันโลกาวินาศ
5. รอจนกระทั่งเครื่องไทม์ถูกประดิษฐ์
6. ข้ามไปสู่อนาคตโดยใช้ไทม์แมชชีน หากคุณซื้อ CPU 1YHz 128 บิตให้ไปที่3,938,453,320 days 20 hours 15 minutes 38 seconds 463 ms 463 μs 374 ns 607 psเมื่อคุณเริ่มเรียกใช้โปรแกรม
7. ... ?
8. กำไร!!!

... ต้องใช้เวลาอย่างน้อย10,783,127ปีแม้ว่าคุณจะมี CPU 1YHz ซึ่ง1,000,000,000,000,000(หรือ1,125,899,906,842,624ถ้าคุณต้องการใช้คำนำหน้าไบนารี) ก็เร็วกว่าซีพียู 1GHz

ดังนั้นแทนที่จะรอการคำนวณเสร็จมันจะเป็นการดีกว่าถ้าจะให้อาหารนกพิราบที่เสียบ้านเพราะnนกพิราบตัวอื่นเข้ามาในบ้าน :(

หรือคุณอาจรอจนกระทั่งคอมพิวเตอร์ควอนตัม 128 บิตถูกประดิษฐ์ขึ้น จากนั้นคุณอาจพิสูจน์ว่า GUID นั้นไม่ซ้ำกันโดยใช้โปรแกรมของคุณในเวลาที่เหมาะสม (อาจ)

คุณได้ลองใช้วิธีbegin = begin + new BigInteger((long)1)เริ่มต้น ++ แล้วหรือยัง?

หากจำนวนของ UUID ที่ถูกสร้างขึ้นเป็นไปตามกฎหมายของมัวร์ความประทับใจที่ไม่เคยมีของ GUID ในอนาคตอันใกล้นี้เป็นเท็จ

ด้วย 2 ^ 128 UUIDs ใช้เวลาเพียง 18 เดือนเท่านั้น * Log2 (2 ^ 128) ~ = 192 ปีก่อนที่เราจะหมด UUID ทั้งหมด

และฉันเชื่อว่าในไม่กี่ปีที่ผ่านมานับตั้งแต่การยอมรับ UUID จำนวนมากความเร็วที่เราสร้าง UUID นั้นเพิ่มขึ้นเร็วกว่าที่กฎหมายของ Moore กำหนดไว้ กล่าวอีกนัยหนึ่งเราอาจมีเวลาน้อยกว่า 192 ปีจนกระทั่งเราต้องรับมือกับวิกฤติ UUID นั่นเร็วกว่าการสิ้นสุดของจักรวาล

แต่เนื่องจากเราจะไม่หมดพวกเขาภายในสิ้นปี 2555 เราจะปล่อยให้สายพันธุ์อื่น ๆ กังวลเกี่ยวกับปัญหานี้

อัตราต่อรองของบั๊กในรหัสสร้าง GUID นั้นสูงกว่าอัตราต่อรองของอัลกอริทึมที่สร้างการชนกันมาก อัตราต่อรองของบั๊กในโค้ดของคุณเพื่อทดสอบ GUID นั้นยิ่งใหญ่กว่า ยอมแพ้.

โปรแกรมแม้ว่าข้อผิดพลาดจะแสดงให้เห็นว่า GUID นั้นไม่ซ้ำกัน ผู้ที่พยายามพิสูจน์สิ่งที่ตรงกันข้ามจะหายไปในจุดนี้ คำสั่งนี้เพียงพิสูจน์การใช้งานที่อ่อนแอของความแตกต่างของ GUID บางส่วน

GUID ไม่จำเป็นต้องมีเอกลักษณ์ตามคำจำกัดความมันเป็นเอกลักษณ์อย่างสูงตามคำนิยาม คุณเพียงขัดเกลาความหมายของสูง ขึ้นอยู่กับรุ่นของตัวเรียกใช้งาน (MS หรืออื่น ๆ ), การใช้งานของ VM, ฯลฯ คำจำกัดความของการเปลี่ยนแปลงที่สูง (ดูลิงค์ในโพสต์ก่อนหน้า)

คุณสามารถย่อตาราง 128 บิตให้สั้นลงเพื่อพิสูจน์จุดของคุณ ทางออกที่ดีที่สุดคือการใช้สูตรแฮชเพื่อย่อตารางของคุณซ้ำซ้อนแล้วใช้ค่าเต็มเมื่อแฮชชนกันและสร้าง GUID ขึ้นมาใหม่ หากทำงานจากสถานที่ต่างกันคุณจะต้องเก็บคู่กุญแจแฮช / รหัสเต็มไว้ในตำแหน่งกลาง

Ps: หากเป้าหมายเพียงเพื่อสร้างค่า x จำนวนต่าง ๆ ให้สร้างตารางแฮชของความกว้างนี้และเพียงตรวจสอบค่าแฮช

ไม่ให้กองไฟที่นี่ แต่มันเกิดขึ้นจริงและใช่ฉันเข้าใจเรื่องตลกที่คุณให้กับผู้ชายคนนี้ แต่ GUID มีเอกลักษณ์เฉพาะในหลักการฉันชนเข้ากับเธรดนี้เพราะมีข้อผิดพลาด ใน WP7 อีมูเลเตอร์ซึ่งหมายความว่าทุกครั้งที่บูทเครื่องจะให้ SAME GUID ทุกครั้งที่มันถูกเรียก! ดังนั้นในทางทฤษฎีแล้วคุณไม่สามารถมีความขัดแย้งได้หากมีปัญหาในการสร้าง GUI ดังกล่าวคุณจะได้รับข้อมูลซ้ำซ้อน

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

เนื่องจากส่วนหนึ่งของการสร้าง Guid ขึ้นอยู่กับเวลาของเครื่องในปัจจุบันทฤษฎีของฉันที่จะได้ Guid ที่ซ้ำกันคือ:

1. ทำการติดตั้ง Windows ใหม่ทั้งหมด
2. สร้างสคริปต์เริ่มต้นที่รีเซ็ตเวลาเป็น 2010-01-01 12:00:00 เช่นเดียวกับที่ Windows บูทขึ้น
3. หลังจากสคริปต์เริ่มทำงานจะทำให้แอปพลิเคชันของคุณสร้าง Guid
4. โคลนการติดตั้ง Windows นี้เพื่อให้คุณแยกแยะความแตกต่างเล็กน้อยที่อาจเกิดขึ้นในการบูทเครื่องครั้งต่อไป
5. re-image ฮาร์ดไดรฟ์ด้วยภาพนี้และทำการบูทเครื่องสองสามครั้ง

สำหรับฉัน .. เวลาที่ใช้ในการสร้างแกนเดี่ยวเพื่อสร้าง UUIDv1 รับประกันว่ามันจะไม่ซ้ำกัน แม้ในสถานการณ์ที่มีหลายคอร์หากตัวสร้าง UUID อนุญาตให้สร้าง UUID เพียงครั้งเดียวในแต่ละครั้งสำหรับทรัพยากรเฉพาะของคุณ (โปรดจำไว้ว่าทรัพยากรหลาย ๆ อย่างสามารถใช้ประโยชน์ UUID เดียวกันได้ทั้งหมด แต่ไม่น่าเป็นไปได้ จะมี UUID มากกว่าพอที่จะให้คุณอยู่ได้จนกว่าการประทับเวลาจะหมดลง ณ จุดนี้ฉันสงสัยจริงๆว่าคุณจะสนใจ

นี่คือวิธีแก้ปัญหาเช่นกัน:

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

หมายเหตุ: ต้องใช้ Qt แต่ฉันรับประกันได้ว่าถ้าคุณปล่อยให้มันรันนานพอมันอาจจะเจอ

(หมายเหตุ: จริง ๆ แล้วตอนนี้ที่ฉันดูมันอาจมีบางอย่างเกี่ยวกับอัลกอริธึมการสร้างที่ป้องกัน uuids ที่สร้างขึ้นสองอันที่ชนกัน - แต่ฉันสงสัยมัน)

ทางออกเดียวที่จะพิสูจน์ว่า GUID นั้นไม่เหมือนใครคือการมี World GUID Pool ทุกครั้งที่มีการสร้าง GUID ควรจะลงทะเบียนกับองค์กร หรือ heck เราอาจรวมถึงมาตรฐานที่ผู้สร้าง GUID ทุกคนต้องลงทะเบียนโดยอัตโนมัติและเพื่อที่จะต้องมีการเชื่อมต่ออินเทอร์เน็ตที่ใช้งาน!