2

我对 C# 相当陌生，我制作了一个模拟乐透抽奖的简单程序。它采用第一个（随机）数字并计算赢得多少平局。这是波兰乐透，所以有 6 个号码可以匹配。

当程序以简单的 for 循环运行时，一切正常。但是有一个问题，当我使用 Parallel For 或任何其他多任务或多线程选项时。

首先是代码：

class Program
{
    public static int howMany = 100;

    static void Main(string[] args)
    {

        Six my;
        Six computers;
        long sum = 0;
        double avg = 0;
        int min = 1000000000;
        int max = 0;



        for (int i = 0; i < howMany; i++)
        {
            my = new Six();
            Console.WriteLine((i + 1).ToString() + " My: " + my.ToString());

            int counter = 0;
            do
            {
                computers = new Six();
                counter++;
            } while (!my.Equals(computers));
            Console.WriteLine((i + 1).ToString() + " Computers: " + computers.ToString());
            Console.WriteLine(counter.ToString("After: ### ### ###") + "\n");
            if (counter < min)
                min = counter;
            if (counter > max)
                max = counter;
            sum += counter;
        }

        avg = sum / howMany;
        Console.WriteLine("Average: " + avg);
        Console.WriteLine("Sum: " + sum);
        Console.WriteLine("Min: " + min);
        Console.WriteLine("Max: " + max);

        Console.Read();
    }

}







class Six : IEquatable<Six>
{
    internal byte first;
    internal byte second;
    internal byte third;
    internal byte fourth;
    internal byte fifth;
    internal byte sixth;
    private static Random r = new Random();

    public Six()
    {

        GenerateRandomNumbers();
    }

    public bool Equals(Six other)
    {
        if (this.first == other.first
            && this.second == other.second
            && this.third == other.third
            && this.fourth == other.fourth
            && this.fifth == other.fifth
            && this.sixth == other.sixth)
            return true;
        else
            return false;
    }

    private void GenerateRandomNumbers()
    {
        byte[] numbers = new byte[6];
        byte k = 0;
        for (int i = 0; i < 6; i++)
        {
            do
            {
                k = (byte)(r.Next(49) + 1);
            }while (numbers.Contains(k));

            numbers[i] = k;
            k = 0;
        }

        Array.Sort(numbers);

        this.first = numbers[0];
        this.second = numbers[1];
        this.third = numbers[2];
        this.fourth = numbers[3];
        this.fifth = numbers[4];
        this.sixth = numbers[5];
    }

    public override string ToString()
    {
        return this.first + ", " + this.second + ", " + this.third + ", " + this.fourth + ", " + this.fifth + ", " + this.sixth;
    }

}

当我尝试使其成为 Parallel.For 时：

        long sum = 0;
        double avg = 0;
        int min = 1000000000;
        int max = 0;


        Parallel.For(0, howMany, (i) =>
        {
            Six my = new Six();
            Six computers;
            Console.WriteLine((i + 1).ToString() + " My: " + my.ToString());

            int counter = 0;
            do
            {
                computers = new Six();

                // Checking when it's getting stuck
                if (counter % 100 == 0)
                    Console.WriteLine(counter);

                counter++;
            } while (!my.Equals(computers));
            Console.WriteLine((i + 1).ToString() + " Computers: " + computers.ToString());
            Console.WriteLine(counter.ToString("After: ### ### ###") + "\n");

            // It never get to this point, so there is no problem with "global" veriables
            if (counter < min)
                min = counter;
            if (counter > max)
                max = counter;
            sum += counter;
        });

程序在某个时候卡住了。计数器达到〜3,000-40,000并且拒绝走得更远。

我尝试了什么：

  1. 使类成为结构
  2. 每约 1000 次迭代收集垃圾
  3. 使用线程池
  4. 使用任务运行
  5. 仅制作随机类程序成员（厌倦了使六类“更轻”）

但我一无所获。

我知道这对你们中的一些人来说可能是一件非常简单的事情，但是人们必须以某种方式学习；）我什至买了一本关于异步编程的书，以找出它为什么不起作用，但无法弄清楚。

4

2 回答 2

1

Random不是线程安全的...

等待您的代码停止在并行版本中写入新行并暂停。这会停止所有线程。您会注意到所有并行线程都在 while 循环中。

数字数组都是 1,0,0,0,0,0 并且 r.Next 只返回 1。字节数组总是包含它。所以，你打破了Random

要解决此问题，您需要通过每次访问 r.Next 时锁定 r 或将静态声明更改为来使 r 线程安全

private static readonly ThreadLocal<Random> r
     = new ThreadLocal<Random>(() => new Random());

Next电话变成了

k = (byte)(r.Value.Next(49) + 1);

这将为每个线程创建一个新的静态 Random 实例。

正如您所指出的，同时创建许多随机数会产生相同的数字序列，为了解决这个问题，请添加一个种子类

static class RGen
{
    private static Random seedGen = new Random();

    public static Random GetRGenerator()
    {
        lock (seedGen)
        {
            return new Random(seedGen.Next());
        }
    }
}

并将声明更改为

private static readonly ThreadLocal<Random> r
     = new ThreadLocal<Random>(() => RGen.GetRGenerator());

这将确保每个新的随机实例具有不同的种子值。

于 2015-04-16T10:07:11.990 回答
0

我根据 James Barrass 所写的内容找到了一个解决方案：

public static readonly ThreadLocal<Random> r = new ThreadLocal<Random>(() => new Random(Thread.CurrentThread.ManagedThreadId + DateTime.Now.Miliseconds));

这使程序运行良好:)

于 2015-04-16T10:17:43.010 回答