需要帮助C＃ID管理器在异步运行时无法正常工作

我已经为xml存储库编写了id管理器。存储库管理xml文件中的条目，并为添加的每个条目分配唯一的ID（整数）。数据库以相同的方式自动将新ID分配给添加到表中的条目。

该存储库将被异步调用，因此我需要id管理器是线程安全的。我正在使用C＃lock语句，但似乎无济于事。我的单元测试在单线程执行中成功，但是在并行运行时（IE：Task）失败。具体而言，它们只会在大型并行任务超过1000+时失败，即使如此，它们也只会每隔两次失败。

该异常表明它预期为10000，但得到了9998。该异常始终与2个未注册的丢失ID有关。

我到底想念什么？

下面提供了ID Manager代码和单元测试。id管理器利用Linq，因此对于大量ID并不是很注重性能。单元测试TestAsyncRegistration和TestAsyncRandomRegistration是引发异常的测试。

public class IdManager
{
    private List<int> idList = new List<int>();
    private List<int> availableList = new List<int>();

    private int nextId;

    private int bufferCount;
    object obj = new object();

    public ReadOnlyCollection<int> RegisteredIds
    {
        get
        {
            return new ReadOnlyCollection<int>(this.idList);
        }
    }

    public int BufferCount
    {
        get
        {
            return this.bufferCount;
        }
        set
        {
            if (value < 1)
            {
                throw new ArgumentOutOfRangeException("value");
            }

            this.bufferCount = value;
        }
    }

    public IdManager(int bufferCount)
    {
        this.BufferCount = bufferCount;
        this.Reset();
    }

    public IdManager()
        : this(1000)
    {
    }

    public void RegisterId(int id)
    {
        this.RegisterId(new[] { id });
    }

    public void Reset()
    {
        lock (this.obj)
        {
            this.availableList.Clear();
            this.idList.Clear();
            for (var i = 0; i < this.bufferCount; i++)
            {
                this.availableList.Add(i);
            } 
        }
    }

    public void RegisterId(IEnumerable<int> ids)
    {
        lock (this.obj)
        {
            var distinct = ids.Except(this.idList);
            this.idList.AddRange(distinct);
            this.availableList = this.availableList.Except(this.idList).ToList(); 
        }
    }

    public int NewId()
    {
        lock (this.obj)
        {
            if (this.availableList.Count > 0)
            {
                var item = this.availableList[0];
                this.availableList.RemoveAt(0);
                this.idList.Add(item);
                return item;
            }

            var max = this.idList.Max();

            for (var i = 1; i < this.bufferCount; i++)
            {
                this.availableList.Add(max + i);
            }

            this.availableList = this.availableList.Except(this.idList).ToList();

            return this.NewId(); 
        }
    }
}

...以及单元测试代码...

[TestClass]
public class IdManagerTests
{
    [TestMethod]
    public void TestSequence()
    {
        var manager = new IdManager(5);
        for (var i = 0; i < manager.BufferCount + 10; i++)
        {
            Assert.AreEqual(i, manager.NewId());
        }
    }

    [TestMethod]
    public void TestBrokenSequence()
    {
        var manager = new IdManager(5);
        manager.RegisterId(1);
        Assert.AreEqual(0, manager.NewId());
        Assert.AreEqual(2, manager.NewId());
        for (var i = 3; i < manager.BufferCount + 10; i++)
        {
            Assert.AreEqual(i, manager.NewId());
        }
    }

    [TestMethod]
    public void TestForwardSequence()
    {
        var manager = new IdManager(5);
        manager.RegisterId(0);
        manager.RegisterId(1);
        manager.RegisterId(2);
        Assert.AreEqual(3, manager.NewId());
        Assert.AreEqual(4, manager.NewId());
        for (var i = 5; i < manager.BufferCount + 10; i++)
        {
            Assert.AreEqual(i, manager.NewId());
        }
    }

    [TestMethod]
    public void TestBackwardSequence()
    {
        var manager = new IdManager(5);
        manager.RegisterId(2);
        manager.RegisterId(1);
        manager.RegisterId(0);
        Assert.AreEqual(3, manager.NewId());
        Assert.AreEqual(4, manager.NewId());
        for (var i = 5; i < manager.BufferCount + 10; i++)
        {
            Assert.AreEqual(i, manager.NewId());
        }
    }

    [TestMethod]
    public async Task TestLargeNumbersRegistration()
    {
        // register a list of id's from 0 to 1000
        var list = new List<int>();
        for (int i = 0; i < 1000; i++)
        {
            list.Add(i);
        }

        var manager = new IdManager(1000);
        manager.RegisterId(list);

        var taskCount = 10000;
        var taskList = new Task[taskCount];
        var idValue = 0;
        for (int i = 0; i < taskList.Length; i++)
        {
            manager.RegisterId(idValue++);
        }

        Assert.AreEqual(taskCount, manager.NewId());
    }

    [TestMethod]
    public async Task TestAsyncRegistration()
    {
        // register a list of id's from 0 to 1000
        var list = new List<int>();
        for (int i = 0; i < 1000; i++)
        {
            list.Add(i);
        }

        var manager = new IdManager(1000);
        manager.RegisterId(list);

        var taskCount = 10000;
        var taskList = new Task[taskCount];
        var idValue = 0;
        for (int i = 0; i < taskList.Length; i++)
        {
            taskList[i] = Task.Factory.StartNew(() => manager.RegisterId(idValue++));
        }

        Task.WaitAll(taskList);

        Assert.AreEqual(taskCount, manager.NewId());
    }

    [TestMethod]
    public async Task TestAsyncRandomRegistration()
    {
        // register a list of id's from 0 to 1000
        var list = new List<int>();
        for (int i = 0; i < 1000; i++)
        {
            list.Add(i);
        }

        // randomize the order of the id's in the list
        var random = new Random((int)DateTime.Now.Ticks);
        var randomizedList = from item in list
                             orderby random.Next()
                             select item;

        var manager = new IdManager(1000);
        manager.RegisterId(randomizedList);

        var taskCount = 10000;
        var taskList = new Task[taskCount];
        var idValue = 0;
        for (int i = 0; i < taskList.Length; i++)
        {
            taskList[i] = Task.Factory.StartNew(() => manager.RegisterId(idValue++));
        }

        Task.WaitAll(taskList);

        Assert.AreEqual(taskCount, manager.NewId());
    }
}