Track progress when using TPL's Parallel.ForEach

后端 未结 3 1662
爱一瞬间的悲伤
爱一瞬间的悲伤 2021-02-07 11:36

What is the best way way to track progress in the following

long total = Products.LongCount();
long current = 0;
double Progress = 0.0;

Parallel.ForEach(Produc         


        
相关标签:
3条回答
  • 2021-02-07 11:51

    Jon's solution is good, if you need simple synchronization like this, your first attempt should almost always use lock. But if you measure that the locking slows things too much, you should think about using something like Interlocked.

    In this case, I would use Interlocked.Increment to increment the current count, and change Progress into a property:

    private long total;
    private long current;
    public double Progress
    {
        get
        {
            if (total == 0)
                return 0;
            return (double)current / total;
        }
    }
    
    …
    
    this.total = Products.LongCount();
    this.current = 0;
    
    Parallel.ForEach(Products, product =>
    {
        try
        {
            var price = GetPrice(SystemAccount, product);
            SavePrice(product, price);
        }
        finally
        {
            Interlocked.Increment(ref this.current);
        }
    });
    

    Also, you might want to consider what to do with exceptions, I'm not sure that iterations that ended with an exception should be counted as done.

    0 讨论(0)
  • 2021-02-07 12:06

    A solution without using any blocking in the body:

    long total = Products.LongCount();
    BlockingCollection<MyState> states = new BlockingCollection<MyState>();
    
    Parallel.ForEach(Products, () =>
    {
        MyState myState = new MyState();
        states.Add(myState);
        return myState;
    },
    (i, state, arg3, myState) =>
    {
        try
        {
            var price = GetPrice(SystemAccount, product);
            SavePrice(product,price);
        }
        finally
        {
            myState.value++;
            return myState;
        }
    },
    i => { }
    );
    

    Then, to access the current progress:

    (float)states.Sum(state => state.value) / total
    
    0 讨论(0)
  • 2021-02-07 12:13

    Since you are just doing a few quick calculations, ensure atomicity by locking on an appropriate object:

    long total = Products.LongCount();
    long current = 0;
    double Progress = 0.0;
    var lockTarget = new object();
    
    Parallel.ForEach(Products, product =>
    {
        try
        {
            var price = GetPrice(SystemAccount, product);
            SavePrice(product,price);
        }
        finally
        {
            lock (lockTarget) {
                Progress = ++this.current / total;
            }
        }});
    
    0 讨论(0)
提交回复
热议问题