c# - 以优化的、线程安全的方式返回数字序列

Question

我正在寻找一些关于编写一些线程安全、优化、优雅的代码来执行以下操作的建议:

我想要一个静态方法来返回一个整数序列。因此，例如，应用程序启动，线程 1 调用 GetSequence 方法并说它要取 3，因此它取回了一个由 0,1,2 组成的整数数组。线程 2 然后调用该方法并说给我 4，因此它返回 3、4、5、6。多个线程可以同时调用该方法。

为了说明我正在考虑的事情，这是我的尝试:

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

namespace SequenceNumberService
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] numbers = NumberSequenceService.GetSequence(3);

            foreach (var item in numbers)
            {
                Console.WriteLine(item.ToString());
            }

            // Writes out:
            // 0
            // 1
            // 2

            Console.ReadLine();
        }
    }

    public static class NumberSequenceService
    {
        private static int m_LastNumber;
        private static object m_Lock = new Object();

        public static int[] GetSequence(int take)
        {
            int[] returnVal = new int[take];
            int lastNumber;

            // Increment the last audit number, based on the take value.
            // It is here where I am concerned that there is a threading issue, as multiple threads
            // may hit these lines of code at the same time.  Should I just put a lock around these two lines
            // of code, or is there a nicer way to achieve this.
            lock (m_Lock)
            {
                m_LastNumber = m_LastNumber + take;
                lastNumber = m_LastNumber;
            }

            for (int i = take; i > 0; i--)
            {
                returnVal[take - i] = lastNumber - i;
            }

            return returnVal;
        }
    }
}

因此我的问题是:我是在以最好的方式解决这个问题，还是有另一种方法来实现这个目标？有什么优化此代码的建议吗？

非常感谢您的帮助。

Answer 1

您可能想查看 Interlocked类，它是 Increment和 Add方法:

public static Int32 num = 0;

public static Int32 GetSequence() 
{ 
    return Interlocked.Increment(ref num); 
}

public static IEnumerable<Int32> GetSequenceRange(Int32 count) 
{ 
    var newValue = Interlocked.Add(ref num, count);
    return Enumerable.Range(newValue - count, count);
}