Question

此代码仅在调试模式下正常工作。我无法理解错误。

我尝试修改代码，但没有任何进展。如果第一个参数为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
}
//);

Answer 1

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

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);

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

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;
    }
});

Answer 2

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

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

PetSerAl的答案显示了可能的解决方案。可能最开始的是lock中最简单的一个。如果结果太慢，请寻找更复杂的解决方案，包括那些使用本地状态的解决方案。

Code Parallel.For仅适用于调试模式

2 个答案: