C# 多线程处理List数据的示例代码

我们来详细讲解一下“C# 多线程处理List数据的示例代码”的完整攻略吧。

1. 理解多线程处理List数据的必要性

在C#中，当需要处理大量数据时，多线程是提高程序效率的一种好方式，特别是在处理大规模的数据集合时，利用多线程可以缩短程序处理时间，提高程序的执行效率。

2. 实现多线程处理List数据的示例代码

下面我们来看一下实现多线程处理List数据的示例代码。

class Program
{
    static void Main(string[] args)
    {
        int count = 1000000;
        List<int> list = new List<int>();
        for(int i = 0; i < count; i++)
        {
            list.Add(i);
        }

        int numThreads = 4; //设定线程数为4
        int chunkSize = count / numThreads; //划分每个线程处理的数据大小

        List<Task<int>> tasks = new List<Task<int>>();
        for(int i = 0; i < numThreads; i++)
        {
            int startIndex = i * chunkSize;
            int endIndex = (i == numThreads - 1) ? count : (i + 1) * chunkSize;
            Task<int> task = Task.Factory.StartNew(() => ProcessChunk(list, startIndex, endIndex));
            tasks.Add(task);
        }

        int total = 0;
        foreach(Task<int> task in tasks)
        {
            total += task.Result;
        }
        Console.WriteLine("Sum is " + total);
    }

    static int ProcessChunk(List<int> list, int startIndex, int endIndex)
    {
        int sum = 0;
        for(int i = startIndex; i < endIndex; i++)
        {
            sum += list[i];
        }
        return sum;
    }
}

该示例代码首先生成一个包含了100万个整数的List，然后利用Task.Factory.StartNew()来创建4个线程分别处理不同的数据块，最后将每个线程处理的结果相加得到总和。

3. 示例1：计算List中大于一定数值的元素个数

在实际应用中，我们很少直接计算List的总和，更多的情况是需要计算满足一定条件的元素个数，比如计算List中大于一定数值的元素个数。

示例代码如下：

class Program
{
    static void Main(string[] args)
    {
        int count = 1000000;
        List<int> list = new List<int>();
        for(int i = 0; i < count; i++)
        {
            list.Add(i);
        }

        int numThreads = 4; //设定线程数为4
        int chunkSize = count / numThreads; //划分每个线程处理的数据大小

        int greaterThan = 500000; //设定计算大于该数值的元素个数

        List<Task<int>> tasks = new List<Task<int>>();
        for(int i = 0; i < numThreads; i++)
        {
            int startIndex = i * chunkSize;
            int endIndex = (i == numThreads - 1) ? count : (i + 1) * chunkSize;
            Task<int> task = Task.Factory.StartNew(() => CountGreaterThan(list, startIndex, endIndex, greaterThan));
            tasks.Add(task);
        }

        int total = 0;
        foreach(Task<int> task in tasks)
        {
            total += task.Result;
        }
        Console.WriteLine("Count is " + total);
    }

    static int CountGreaterThan(List<int> list, int startIndex, int endIndex, int value)
    {
        int count = 0;
        for(int i = startIndex; i < endIndex; i++)
        {
            if(list[i] > value)
            {
                count++;
            }
        }
        return count;
    }
}

该示例代码实现了计算List中大于500000的元素个数，首先生成一个包含了100万个整数的List，然后利用Task.Factory.StartNew()来创建4个线程分别处理不同的数据块，最后将每个线程处理的结果相加得到总数。

4. 示例2：计算List中元素之和的平方根

再看一个计算List中元素之和的平方根的示例代码。

class Program
{
    static void Main(string[] args)
    {
        int count = 1000000;
        List<int> list = new List<int>();
        for(int i = 0; i < count; i++)
        {
            list.Add(i);
        }

        int numThreads = 4; //设定线程数为4
        int chunkSize = count / numThreads; //划分每个线程处理的数据大小

        List<Task<double>> tasks = new List<Task<double>>();
        for(int i = 0; i < numThreads; i++)
        {
            int startIndex = i * chunkSize;
            int endIndex = (i == numThreads - 1) ? count : (i + 1) * chunkSize;
            Task<double> task = Task.Factory.StartNew(() => CalculateSum(list, startIndex, endIndex));
            tasks.Add(task);
        }

        double total = 0;
        foreach(Task<double> task in tasks)
        {
            total += task.Result;
        }
        Console.WriteLine("Square root of sum is " + Math.Sqrt(total));
    }

    static double CalculateSum(List<int> list, int startIndex, int endIndex)
    {
        int sum = 0;
        for(int i = startIndex; i < endIndex; i++)
        {
            sum += list[i];
        }
        return Math.Pow(sum, 2);
    }
}

该示例代码实现了计算List中元素之和的平方根，首先生成一个包含了100万个整数的List，然后利用Task.Factory.StartNew()来创建4个线程分别处理不同的数据块，最后将每个线程处理的结果相加得到总和，再取平方根。

5. 总结

在本篇攻略中，我们学习了关于C#多线程处理List数据的示例代码的详细讲解，包含了理解多线程处理List数据的必要性、实现多线程处理List数据的示例代码，并给出了2条示例说明，希望对你有所帮助。