public sealed class SimpleTaskScheduler : TaskScheduler, IDisposable
{
    BlockingCollection<Task> _tasks = new BlockingCollection<Task>();
    List<Thread> _threads = new List<Thread>();

public SimpleTaskScheduler(int initNumberOfThreads = 3)
    {
        if (initNumberOfThreads < 1)
            throw new ArgumentOutOfRangeException();

_threads.AddRange(Enumerable.Range(0, initNumberOfThreads).Select(_ => CreateThread()));
    }

Thread CreateThread()
    {
        var thread = new Thread(() =>
        {
            foreach (var t in _tasks.GetConsumingEnumerable())
            {
                TryExecuteTask(t);
            }
        });

thread.IsBackground = true;
        thread.Start();
        return thread;
    }

protected override IEnumerable<Task> GetScheduledTasks()
    {
        //这个函数好像没有调过，返回null也不影响功能
        return _tasks.ToArray();
    }

protected override void QueueTask(Task task)
    {
        _tasks.Add(task);
    }

protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        return TryExecuteTask(task);
    }

public override int MaximumConcurrencyLevel { get { return _threads.Count; } }

#region IDisposable 成员

public void Dispose()
    {
        if (_tasks == null)        //防止重入
            return;

_tasks.CompleteAdding();
        _threads.ForEach(t => t.Join());

_tasks.Dispose();
        _tasks = null;
    }

#endregion
}