c# - 构建线程安全的 GUID 增量器-6ren

c# - 构建线程安全的 GUID 增量器

转载作者：太空狗更新时间：2023-10-29 23:05:42

在我下面的代码中，我锁定了 guid，以尝试使其线程安全。在我的示例应用程序中，大约每运行 10 次我就会得到一个“重复 key ”。也就是说，我得到了一个副本，这不是我需要的。

有什么方法可以使“.NextGuid”线程安全吗？

using System;    
namespace MyConsoleOne.BAL
{
    public class GuidStore
    {
        private static object objectlock = new object();    
        private Guid StartingGuid { get; set; }    
        private Guid? LastGuidHolder { get; set; }    
        public GuidStore(Guid startingGuid)
        {
            this.StartingGuid = startingGuid;
        }

        public Guid? GetNextGuid()
        {
            lock (objectlock)
            {
                if (this.LastGuidHolder.HasValue)
                {
                    this.LastGuidHolder = Increment(this.LastGuidHolder.Value);
                }
                else
                {
                    this.LastGuidHolder = Increment(this.StartingGuid);
                }
            }    
            return this.LastGuidHolder;
        }

        private Guid Increment(Guid guid)
        {    
            byte[] bytes = guid.ToByteArray();    
            byte[] order = { 15, 14, 13, 12, 11, 10, 9, 8, 6, 7, 4, 5, 0, 1, 2, 3 };    
            for (int i = 0; i < 16; i++)
            {
                if (bytes[order[i]] == byte.MaxValue)
                {
                    bytes[order[i]] = 0;
                }
                else
                {
                    bytes[order[i]]++;
                    return new Guid(bytes);
                }
            }    
            throw new OverflowException("Guid.Increment failed.");
        }
    }
}

using MyConsoleOne.BAL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyConsoleOne
{
    class Program
    {
        static void Main(string[] args)
        {
            GuidStore gs = new GuidStore(Guid.NewGuid());

            for (int i = 0; i < 1000; i++)
            {
                Console.WriteLine(i);
                Dictionary<Guid, int> guids = new Dictionary<Guid, int>();
                Parallel.For(0, 1000, j =>
                {
                    Guid? currentGuid = gs.GetNextGuid();
                    guids.Add(currentGuid.Value, j);
                    Console.WriteLine(currentGuid);
                }); // Parallel.For
            }    
            Console.WriteLine("Press ENTER to Exit");
            Console.ReadLine();
        }
    }
}

我的代码是以下内容的组合:

由于我收到“为什么不使用 Guid.NewGuid”的问题，我将在此处提供原因:

我有一个父进程，它有一个由 Guid.NewGuid() 创建的唯一标识符。我将把它称为“父 guid”。该父进程将创建 N 个文件。如果我从头开始编写，我会在文件名末尾附加“N”。因此，如果父 Guid 是“11111111-1111-1111-1111-111111111111”，例如，我会写文件

"11111111-1111-1111-1111-111111111111_1.txt"
"11111111-1111-1111-1111-111111111111_2.txt"
"11111111-1111-1111-1111-111111111111_3.txt"

等。但是，通过与客户端的现有“契约(Contract)”:::文件名中必须有一个(唯一的)Guid，并且没有那个“N”(1、2 等)值在文件名中(这个“契约(Contract)”已经存在多年，所以它几乎是一成不变的)。有了这里列出的功能，我将能够保留“契约(Contract)”，但文件名松散地绑定(bind)到“父”Guid(父级再次由 Guid.NewGuid() 生成)。冲突不是文件名的问题(它们被放在一个不同的文件夹下用于“进程”执行)。碰撞是“父”Guid 的一个问题。但同样，这已经用 Guid.NewGuid 处理了。

因此，使用“11111111-1111-1111-1111-111111111111”的起始 Guid，我将能够编写如下文件名:

OTHERSTUFF_111111111-1111-1111-1111-111111111112_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111113_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111114_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111115_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111116_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111117_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111118_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-111111111119_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-11111111111a_MORESTUFF.txt
OTHERSTUFF_111111111-1111-1111-1111-11111111111b_MORESTUFF.txt

所以在我上面的示例中，“父 guid”由“this.StartingGuid”表示......然后我从中得到“递增”的 guid。

还有。我可以编写更好的单元测试，因为现在我可以提前知道文件名。

追加:

最终代码版本:

public class GuidStore
{
    private static object objectlock = new object();

    private static int[] byteOrder = { 15, 14, 13, 12, 11, 10, 9, 8, 6, 7, 4, 5, 0, 1, 2, 3 };

    private Guid StartingGuid { get; set; }

    private Guid? LastGuidHolder { get; set; }

    public GuidStore(Guid startingGuid)
    {
        this.StartingGuid = startingGuid;
    }

    public Guid GetNextGuid()
    {
        return this.GetNextGuid(0);
    }

    public Guid GetNextGuid(int firstGuidOffSet)
    {
        lock (objectlock)
        {
            if (this.LastGuidHolder.HasValue)
            {
                this.LastGuidHolder = Increment(this.LastGuidHolder.Value);
            }
            else
            {
                this.LastGuidHolder = Increment(this.StartingGuid);
                for (int i = 0; i < firstGuidOffSet; i++)
                {
                    this.LastGuidHolder = Increment(this.LastGuidHolder.Value);
                }
            }

            return this.LastGuidHolder.Value;
        }
    }

    private static Guid Increment(Guid guid)
    {
        var bytes = guid.ToByteArray();
        var canIncrement = byteOrder.Any(i => ++bytes[i] != 0);
        return new Guid(canIncrement ? bytes : new byte[16]);
    }
}

和单元测试:

public class GuidStoreUnitTests
{
    [TestMethod]
    public void GetNextGuidSimpleTest()
    {
        Guid startingGuid = new Guid("11111111-1111-1111-1111-111111111111");
        GuidStore gs = new GuidStore(startingGuid);


        List<Guid> guids = new List<Guid>();

        const int GuidCount = 10;

        for (int i = 0; i < GuidCount; i++)
        {
            guids.Add(gs.GetNextGuid());
        }

        Assert.IsNotNull(guids);
        Assert.AreEqual(GuidCount, guids.Count);
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111112")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111113")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111114")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111115")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111116")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111117")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111118")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-111111111119")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-11111111111a")));
        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-11111111111b")));
    }

    [TestMethod]
    public void GetNextGuidWithOffsetSimpleTest()
    {
        Guid startingGuid = new Guid("11111111-1111-1111-1111-111111111111");
        GuidStore gs = new GuidStore(startingGuid);

        List<Guid> guids = new List<Guid>();

        const int OffSet = 10;

        guids.Add(gs.GetNextGuid(OffSet));

        Assert.IsNotNull(guids);
        Assert.AreEqual(1, guids.Count);

        Assert.IsNotNull(guids.FirstOrDefault(g => g == new Guid("11111111-1111-1111-1111-11111111111c")));
    }

    [TestMethod]
    public void GetNextGuidMaxRolloverTest()
    {
        Guid startingGuid = new Guid("ffffffff-ffff-ffff-ffff-ffffffffffff");
        GuidStore gs = new GuidStore(startingGuid);

        List<Guid> guids = new List<Guid>();

        const int OffSet = 10;

        guids.Add(gs.GetNextGuid(OffSet));

        Assert.IsNotNull(guids);
        Assert.AreEqual(1, guids.Count);

        Assert.IsNotNull(guids.FirstOrDefault(g => g == Guid.Empty));
    }

    [TestMethod]
    public void GetNextGuidThreadSafeTest()
    {
        Guid startingGuid = Guid.NewGuid();
        GuidStore gs = new GuidStore(startingGuid);

        /* The "key" of the ConcurrentDictionary must be unique, so this will catch any duplicates */
        ConcurrentDictionary<Guid, int> guids = new ConcurrentDictionary<Guid, int>();
        Parallel.For(
            0,
            1000,
            j =>
            {
                Guid currentGuid = gs.GetNextGuid();
                if (!guids.TryAdd(currentGuid, j))
                {
                    throw new ArgumentOutOfRangeException("GuidStore.GetNextGuid ThreadSafe Test Failed");
                }
            }); // Parallel.For
    }

    [TestMethod]
    public void GetNextGuidTwoRunsProduceSameResultsTest()
    {
        Guid startingGuid = Guid.NewGuid();

        GuidStore gsOne = new GuidStore(startingGuid);

        /* The "key" of the ConcurrentDictionary must be unique, so this will catch any duplicates */
        ConcurrentDictionary<Guid, int> setOneGuids = new ConcurrentDictionary<Guid, int>();
        Parallel.For(
            0,
            1000,
            j =>
            {
                Guid currentGuid = gsOne.GetNextGuid();
                if (!setOneGuids.TryAdd(currentGuid, j))
                {
                    throw new ArgumentOutOfRangeException("GuidStore.GetNextGuid ThreadSafe Test Failed");
                }
            }); // Parallel.For

        gsOne = null;

        GuidStore gsTwo = new GuidStore(startingGuid);

        /* The "key" of the ConcurrentDictionary must be unique, so this will catch any duplicates */
        ConcurrentDictionary<Guid, int> setTwoGuids = new ConcurrentDictionary<Guid, int>();
        Parallel.For(
                0,
                1000,
                j =>
                {
                    Guid currentGuid = gsTwo.GetNextGuid();
                    if (!setTwoGuids.TryAdd(currentGuid, j))
                    {
                        throw new ArgumentOutOfRangeException("GuidStore.GetNextGuid ThreadSafe Test Failed");
                    }
                }); // Parallel.For

        bool equal = setOneGuids.Select(g => g.Key).OrderBy(i => i).SequenceEqual(
                         setTwoGuids.Select(g => g.Key).OrderBy(i => i), new GuidComparer<Guid>());

        Assert.IsTrue(equal);
    }
}

internal class GuidComparer<Guid> : IEqualityComparer<Guid>
{
    public bool Equals(Guid x, Guid y)
    {
        return x.Equals(y);
    }

    public int GetHashCode(Guid obj)
    {
        return 0;
    }
}

最佳答案

这里有两个问题:

Dictionary.Add() 不是线程安全的。请改用 ConcurrentDictionary.TryAdd()。
您的 GetNextGuid() 实现有一个竞争条件，因为您在锁外返回 this.LastGuidHolder，所以它可能在它返回之前被另一个线程修改返回。

一个明显的解决方案是将返回移动到锁内:

public Guid? GetNextGuid()
{
    lock (objectlock)
    {
        if (this.LastGuidHolder.HasValue)
        {
            this.LastGuidHolder = Increment(this.LastGuidHolder.Value);
        }
        else
        {
            this.LastGuidHolder = Increment(this.StartingGuid);
        }

        return this.LastGuidHolder;
    }
}

但是，我会将返回类型更改为 Guid - 返回 Guid? 似乎没有任何作用 - 这是应该隐藏的东西类内:

public Guid GetNextGuid()
{
    lock (objectlock)
    {
        if (this.LastGuidHolder.HasValue)
        {
            this.LastGuidHolder = Increment(this.LastGuidHolder.Value);
        }
        else
        {
            this.LastGuidHolder = Increment(this.StartingGuid);
        }

        return this.LastGuidHolder.Value;
    }
}

这是使用 ConcurrentDictionary 的测试方法的一个版本:

static void Main(string[] args)
{
    GuidStore gs = new GuidStore(Guid.NewGuid());

    for (int i = 0; i < 1000; i++)
    {
        Console.WriteLine(i);
        ConcurrentDictionary<Guid, int> guids = new ConcurrentDictionary<Guid, int>();
        Parallel.For(0, 1000, j =>
        {
            Guid currentGuid = gs.GetNextGuid();
            if (!guids.TryAdd(currentGuid, j))
            {
                Console.WriteLine("Duplicate found!");
            }
        }); // Parallel.For
    }

    Console.WriteLine("Press ENTER to Exit");
    Console.ReadLine();
}

说了这么多，我不明白为什么你不只是使用 Guid.NewGuid()...

关于c# - 构建线程安全的 GUID 增量器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40885081/

文章推荐： c# - 使用 JSON 在 C# 中调用 API

文章推荐： c++ - 嵌入式 Boost::Python 和 C++:并行运行

文章推荐： c++ - g++ 4.7.2 用于类型别名的处理似乎被打破

文章推荐： C++ 自动检测 shared_ptr 与 NULL 比较的位置

c# - 我应该使用 Guid 和 Guid.Empty 还是可以为 null 的 Guid？
我有某些场景(例如，一个自定义类来保存 Sql 参数)，其中可能需要也可能不需要变量。传统上，我一直将这些定义为 Guid? 类型，并在使用前使用 myGuid.HasValue 检查有效值。当然在
guid - 为什么 GUID 结构是这样声明的？
在 rpc.h 中，GUID 结构声明如下: typedef struct _GUID { DWORD Data1; WORD Data2; WORD Data3; B
guid - 如何使用特定的 GUID 创建新记录
使用 Dynamics CRM 我试图创建一个实体的实例。我想手动设置 GUID，但如果我拥有作为 DynamicEntity 主键的属性，则会出现以下错误。 Service could not pr
guid - 在不丢失唯一性的情况下将 GUID 字段适配到较小的字段中
我需要将 GUID PK 字段(长度 = 36)发送到只接受 20 个字符长的下游系统。在下游系统中增加字段的长度成本过高。如果我截断该字段，那么我将失去它的唯一性。有什么方法可以在不丢失唯一性的情
guid - 您生成的 GUID 识别您的身份有多容易？
我听说 melissa 蠕虫的创建者因生成的 GUID 可以链接回他使用的计算机的 MAC 地址而被定罪。做到这一点有多难？除了 GUID，他们还需要哪些数据？喜欢 MAC 地址本身还是创建时间？
guid - 使用 GUID 作为上传图像的文件名的任何缺点
使用 GUID 作为文件名和 นด 上传的图像以避免重复有什么缺点吗？最佳答案您的文件名将是唯一的，真的。但是没有任何方法可以按任何顺序对它们进行排序。您可以使用 Unix TimeStamp在
c# - GUID/Guid 互操作的枚举
我正在做一些互操作，需要传递一些 GUID。有没有办法将 GUID 属性添加到枚举值，并且当它被编码时它具有适当的值？基本上我正在尝试转换代码 #if !defined( STATIC_KSDATA
shell - 从命令行用新的 GUID 替换文件中的所有 GUID
我有一个文件，其中包含大量出现的字符串 Guid="GUID HERE" (其中 GUID HERE 在每次出现时都是唯一的 GUID)，我想用新的唯一 GUID 替换每个现有的 GUID。这是在
cryptography - 如何从给定的 GUID 预测下一个 GUID？
我已经向我们的客户发送了 10000 封邮件，每封邮件都有一个格式的链接 http://example.com/LogIn?key={guid} 不幸的是guid我发送的是随机 guids(由 Gui
guid - Breeze:如何为客户端上的新实体创建 GUID key ？
使用 Breeze，在创建实体时填充 GUID 键的最简单方法是什么？最佳答案我假设您的实体已配置为客户端负责为新实体设置 Guid 键。这是 Entity Framework 代码优先实体的 G
guid - GUID 和 UUID 之间有什么区别吗？
我看到这两个首字母缩略词被抛出，我想知道 GUID 和 UUID 之间是否有任何区别？最佳答案简单回答是:**没有区别，它们是同一个东西。 2020-08-20 更新 :虽然 GUID(由 Mic
guid - GUID 是最终 ID 吗？
我注意到有些人不打算使用通常的递增数字作为 ID，而是简单地生成 GUID。优点包括: 快速简单无需跟踪以前的 ID 即使在机器之间互不了解的情况下也能保证唯一性一些缺点是: 可能存在性能瓶颈使
casting - 将非托管 GUID 转换为托管 Guid^
我是 C++/CLI 的新手，我正在尝试将 native C++ GUID 转换为我的 C++/CLI Guid^。尝试转换时: BlockInfo^ blockInfo = gcnew BlockI
guid - GUID 和 UUID 之间有什么区别？
这个问题在这里已经有了答案: 11 年前关闭。 Possible Duplicate: Is there any difference between a GUID and a UUID? GUID
perl - Data::GUID 是否生成有效的 GUID？
我正在使用 Data::GUID生成 GUID。然而，每当我在同一个“ session ”中生成 GUID，即运行脚本时，唯一改变的数字是最前面的数字: 3BAF1240-0573-11E4-B31C
c# - 有没有办法从 Guid 列表中生成 Guid？
我有一个对象列表，它们具有 id 的 guid。我想使用这个对象列表中的 id 创建一个 guid，我可以使用它来确保列表没有改变。如果删除/添加了一个对象，则 guid 会有所不同。我想到的是使用哈
c# - 如何区分空的可空 Guid 或查询字符串中的无效 Guid？
上下文:ASP.NET Web API v2 给定一个类似于这个的 URL: http://localhost/something?id=cbc66d32-ece8-400f-a574-e36b911
c# - 将 Guid 转换为可为空的 Guid
这是将 Guid 转换为 Guid 的惯用方法吗？？ new Guid?(new Guid(myString)); 最佳答案不，这是: Guid? foo = new Guid(myString);
c# - 从非 guid 格式的字符串生成 GUID
我想从输入字符串生成一个 GUID。假设我从用户那里收到了 guid，它是 81a130d2-502f-4cf1-a376-63edeb000e9f 所以我可以这样做: Guid g = Guid.
c# - 为什么无参数的 Guid 构造函数会生成一个空的 GUID？
为什么无参数 Guid 构造函数生成一个空 GUID，而不是像 Guid.NewGuid() 那样默认生成一个？空 Guid 是否有特殊用途？最佳答案 Why does the parameter

太空狗

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c# - 构建线程安全的 GUID 增量器