Question

以前是否有任何以不同的优先级向TPL运行时添加任务的工作？

如果没有，一般来说，我该如何实现呢？

理想情况下，我计划使用生产者 - 消费者模式向TPL添加“todo”工作。有时我会发现低优先级的工作需要升级到高优先级的工作（相对于其他工作）。

如果有人在搜索时会使用一些搜索关键字，请提及它们，因为我还没有找到可以满足我需要的代码。

Answer 1

ParallelExtensionsExtras contains several custom TaskSchedulers可以直接或作为您自己的计划程序的基础。

具体来说，有两个可能对您感兴趣的调度程序：

QueuedTaskScheduler，允许您以不同的优先级安排Task，但不允许更改已排队Task的优先级。
ReprioritizableTaskScheduler，它没有不同的优先级，但允许您将特定的Task移动到队列的前面或后面。（虽然更改优先级是当前等待Task的数量的O（n），如果您同时有多个Task，则可能会出现问题。）

Answer 2

所以这是一个相当天真的并发实现围绕一个相当天真的优先级队列。这里的想法是有一个有序的集合，它保存了真实项目和优先级的对，但是给出了一个只比较优先级的比较器。构造函数采用一个函数来计算给定对象的优先级。

至于实际实施，它们没有得到有效实施，我只是lock围绕着一切。创建更高效的实现将阻止使用SortedSet作为优先级队列，并且重新实现可以同时有效访问的那些之一并不是那么容易。

为了更改项目的优先级，您需要从集合中删除项目，然后再次添加项目，并在不迭代整个集合的情况下找到它，您需要知道旧的优先级以及新的优先事项。

public class ConcurrentPriorityQueue<T> : IProducerConsumerCollection<T>
{
    private object key = new object();
    private SortedSet<Tuple<T, int>> set;

    private Func<T, int> prioritySelector;

    public ConcurrentPriorityQueue(Func<T, int> prioritySelector, IComparer<T> comparer = null)
    {
        this.prioritySelector = prioritySelector;
        set = new SortedSet<Tuple<T, int>>(
            new MyComparer<T>(comparer ?? Comparer<T>.Default));
    }

    private class MyComparer<T> : IComparer<Tuple<T, int>>
    {
        private IComparer<T> comparer;
        public MyComparer(IComparer<T> comparer)
        {
            this.comparer = comparer;
        }
        public int Compare(Tuple<T, int> first, Tuple<T, int> second)
        {
            var returnValue = first.Item2.CompareTo(second.Item2);
            if (returnValue == 0)
                returnValue = comparer.Compare(first.Item1, second.Item1);
            return returnValue;
        }
    }

    public bool TryAdd(T item)
    {
        lock (key)
        {
            return set.Add(Tuple.Create(item, prioritySelector(item)));
        }
    }

    public bool TryTake(out T item)
    {
        lock (key)
        {
            if (set.Count > 0)
            {
                var first = set.First();
                item = first.Item1;
                return set.Remove(first);
            }
            else
            {
                item = default(T);
                return false;
            }
        }
    }

    public bool ChangePriority(T item, int oldPriority, int newPriority)
    {
        lock (key)
        {
            if (set.Remove(Tuple.Create(item, oldPriority)))
            {
                return set.Add(Tuple.Create(item, newPriority));
            }
            else
                return false;
        }
    }

    public bool ChangePriority(T item)
    {
        lock (key)
        {
            var result = set.FirstOrDefault(pair => object.Equals(pair.Item1, item));

            if (object.Equals(result.Item1, item))
            {
                return ChangePriority(item, result.Item2, prioritySelector(item));
            }
            else
            {
                return false;
            }
        }
    }

    public void CopyTo(T[] array, int index)
    {
        lock (key)
        {
            foreach (var item in set.Select(pair => pair.Item1))
            {
                array[index++] = item;
            }
        }
    }

    public T[] ToArray()
    {
        lock (key)
        {
            return set.Select(pair => pair.Item1).ToArray();
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ToArray().AsEnumerable().GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public void CopyTo(Array array, int index)
    {
        lock (key)
        {
            foreach (var item in set.Select(pair => pair.Item1))
            {
                array.SetValue(item, index++);
            }
        }
    }

    public int Count
    {
        get { lock (key) { return set.Count; } }
    }

    public bool IsSynchronized
    {
        get { return true; }
    }

    public object SyncRoot
    {
        get { return key; }
    }
}

如果您拥有IProducerConsumerCollection<T>实例（上述对象所在的实例），则可以将其用作BlockingCollection<T>的内部支持对象，以便更轻松地使用用户界面。

Answer 3

我实现优先级FIFO任务队列它非常简单，就像ActionBlock一样具有优先级。

检查您是否在https://github.com/ido-ran/PriorityTaskQueue

任务并行库中的优先级队列

3 个答案: