代码并行.For仅在调试模式下工作

本文关键字：模式 工作 调试 并行 For 代码 | 更新日期: 2024-10-18 09:23:59

此代码仅在调试模式下正常工作。我不明白出了什么问题。

我试图修改代码，但没有任何进展。如果第一个参数为true，我想将调用函数newRow的结果添加到hashSet中。

foreach (structNumbers sn in numbers)
//Parallel.ForEach(numbers, new ParallelOptions { MaxDegreeOfParallelism = 1 }, (sn) =>
{
    #region                           
    //for (Int32 v = 0; v < 16; v++)
    Parallel.For<Tuple<Boolean, mpz_t, mpz_t>>(0, 16, 
        ()=> { return new Tuple<Boolean, mpz_t, mpz_t>(false, 0, 0); },
        (v, pls, state) =>
    {
        #region
        Interlocked.Increment(ref countChecked);
        //if (newRow(i, j, v, t, index, sn.n, sn.m, out nMin, out mMin) == true)
        //lock(thisLock)
        Tuple<Boolean, mpz_t, mpz_t> res = newRow(i, j, v / 4, v % 4, index, sn.n, sn.m);
        state = new Tuple<bool, mpz_t, mpz_t>(res.Item1, res.Item2, res.Item3);

        return state;
        #endregion
    },
        state => {
            lock (thisLock)
            {
                if (state.Item1 == true)
                {
                    #region  
                    numbersTemp.Add(new structNumbers(state.Item2, state.Item3));
                    //numbersTemp.Add(new structNumbers(nMin, mMin));
                    //Console.WriteLine("bla");
                    #endregion
                }
            }
        }
    );
    #endregion
}
//);

代码并行.For仅在调试模式下工作

如果你想从并行循环中聚合多个结果，那么你可以这样做：

object lockObject=new object();
HashSet<TResult> result=new HashSet<TResult>();
Parallel.For(0,16,() => new List<TResult>(),(i,pls,list) => {
    TResult r;
    if(TryGetResult(i,out r)) {
        list.Add(r);
    }
    return list;
},list => {
    lock(lockObject) {
        result.UnionWith(list);
    }
});

但如果TryGetResult代表了大量的工作（至少它应该足够大，可以证明并行循环的开销），您可以这样做：

object lockObject=new object();
HashSet<TResult> result=new HashSet<TResult>();
Parallel.For(0,16,i => {
    TResult r;
    if(TryGetResult(i,out r)) {
        lock(lockObject) {
            result.Add(r);
        }
    }
});

或者这个：

ConcurrentBag<TResult> bag=new ConcurrentBag<TResult>();
Parallel.For(0,16,i => {
    TResult r;
    if(TryGetResult(i,out r)) {
        bag.Add(r);
    }
});
HashSet<TResult> result=new HashSet<TResult>(bag);

在我看来，带有TLocal类型参数的Parallel.For重载更适合，当你有标量结果时，没有锁就无法更新：

object lockObject=new object();
BigInteger result=BigInteger.Zero;
Parallel.For(0,16,i => {
    BigInteger r=GetBigInteger(i);
    lock(lockObject) {
        result+=r;
    }
});

在这段代码中，添加两个BigInteger可能是一项代价高昂的操作，并且不能并行完成，因此您最好重写如下代码：

object lockObject=new object();
BigInteger result=BigInteger.Zero;
Parallel.For(0,16,() => BigInteger.Zero,(i,pls,subResult) => {
    return subResult+GetBigInteger(i);
},subResult => {
    lock(lockObject) {
        result+=subResult;
    }
});

此版本的Parallel.For()的工作方式是首先将输入拆分为批。然后，对于每个批次，使用localInit委托初始化本地状态，为批次中的每个编号调用body委托，将最后一个状态传递给它，并期望它返回新状态，最后，在最终状态上调用localFinally。

由于您忽略了body输入时的状态，因此您只将每个批次中的最后一项添加到结果中。

PetSerAl的回答显示了可能的解决方案。可能最合理的开始是最简单的lock。如果这太慢，那就寻找更复杂的解决方案，包括那些使用地方州的解决方案。

相关文章：