标签: task-parallel-library

有没有办法在使用该Task.StartNew方法时指定Thread的名称

var task = Task.Factory.StartNew(MyAction, TaskCreationOption.LongRunning, ??ThreadName??);

我编写了一个非常简单的"字数统计"程序,它读取文件并计算文件中每个单词的出现次数.这是代码的一部分:

class Alaki
{
    private static List<string> input = new List<string>();

    private static void exec(int threadcount)
    {
        ParallelOptions options = new ParallelOptions();
        options.MaxDegreeOfParallelism = threadcount;
        Parallel.ForEach(Partitioner.Create(0, input.Count),options, (range) =>
        {
            var dic = new Dictionary<string, List<int>>();
            for (int i = range.Item1; i < range.Item2; i++)
            {
                //make some delay!
                //for (int x = 0; x < 400000; x++) ;                    

                var tokens = input[i].Split();
                foreach (var token in tokens)
                {
                    if (!dic.ContainsKey(token))
                        dic[token] = new List<int>();
                    dic[token].Add(1);
                }
            }
        });

    } …

好吧,基本上我有一堆任务(10),我想同时启动它们并等待它们完成.完成后我想执行其他任务.我读了很多关于这方面的资源,但我无法理解我的具体案例......

这是我目前拥有的(代码已经简化):

public async Task RunTasks()
{
    var tasks = new List<Task>
    {
        new Task(async () => await DoWork()),
        //and so on with the other 9 similar tasks
    }


    Parallel.ForEach(tasks, task =>
    {
        task.Start();
    });

    Task.WhenAll(tasks).ContinueWith(done =>
    {
        //Run the other tasks
    });
}

//This function perform some I/O operations
public async Task DoWork()
{
    var results = await GetDataFromDatabaseAsync();
    foreach (var result in results)
    {
        await ReadFromNetwork(result.Url);
    }
}

所以我的问题是,当我等待任务完成时WhenAll,它告诉我所有任务都已结束,即使它们都没有完成.我尝试添加Console.WriteLine我的内容foreach,当我进入延续任务时,数据不断从我以前的Tasks中进入,并没有真正完成.

我在这做错了什么？

我有一些用c#编写的执行并发代码的东西,大量使用任务并行库(Task and Future continuation chains).

我现在将其移植到F#,并试图找出使用F#Async工作流与TPL中的构造的优缺点.我倾向于TPL,但我认为无论哪种方式都可以.

有没有人有关于在F#中编写并发程序的提示和智慧？

我糊涂了.一个或多个如何Task在一个线程上并行运行？我对并行性的理解显然是错误的.

MSDN的比特我无法理解:

async和await关键字不会导致创建其他线程.异步方法不需要多线程,因为异步方法不能在自己的线程上运行.该方法在当前同步上下文上运行,并仅在方法处于活动状态时在线程上使用时间.

..和:

在启动任务和等待任务之间,您可以启动其他任务.其他任务隐式并行运行,但不会创建其他线程.

取消以下内容的正确方法是什么？

var tcpListener = new TcpListener(connection);
tcpListener.Start();
var client = await tcpListener.AcceptTcpClientAsync();

简单地调用tcpListener.Stop()似乎导致a ObjectDisposedException并且该AcceptTcpClientAsync方法不接受CancellationToken结构.

我完全错过了一些明显的东西吗

TL; DR:运行任务中的死锁StaTaskScheduler.长版:

我使用的是StaTaskScheduler从ParallelExtensionsExtras中通过平行小组,举办由第三方提供的一些遗留STA COM对象.StaTaskScheduler实现细节的描述如下:

好消息是TPL的实现能够在MTA或STA线程上运行,并考虑到底层API的相关差异,如WaitHandle.WaitAll(当方法提供多个等待句柄时,它只支持MTA线程).

我认为这意味着TPL的阻塞部分将使用等待API来提供消息,例如CoWaitForMultipleHandles,以避免在STA线程上调用时出现死锁情况.

在我的情况下,我相信发生以下情况:进程内STA COM对象A调用进程外对象B,然后期望从B通过回调作为传出调用的一部分.

以简化形式:

var result = await Task.Factory.StartNew(() =>
{
    // in-proc object A
    var a = new A(); 
    // out-of-proc object B
    var b = new B(); 
    // A calls B and B calls back A during the Method call
    return a.Method(b);     
}, CancellationToken.None, TaskCreationOptions.None, staTaskScheduler);

问题是,a.Method(b)永远不会回来.据我所知,这是因为内部阻塞等待BlockingCollection<Task>不会引发消息,因此我对引用语句的假设可能是错误的.

EDITED相同的代码工作测试WinForms应用程序的UI线程上执行时(即,提供TaskScheduler.FromCurrentSynchronizationContext()的,而不是staTaskScheduler到Task.Factory.StartNew).

解决这个问题的正确方法是什么？我应该实现一个自定义同步上下文,它将显式地使用消息CoWaitForMultipleHandles …

我试图抛出并捕获AggregateException.我没有在C#上使用异常,但我发现的行为有点令人惊讶.

我的代码是:

var numbers = Enumerable.Range(0, 20);

try
{
    var parallelResult = numbers.AsParallel()
        .Where(i => IsEven(i));
    parallelResult.ForAll(e => Console.WriteLine(e));

}
catch (AggregateException e)
{
    Console.WriteLine("There was {0} exceptions", e.InnerExceptions.Count());
}

它正在调用函数IsEven

private static bool IsEven(int i)
{
    if (i % 10 == 0)
        throw new AggregateException("i");
    return i % 2 == 0;
}

抛出AggregateException.

我希望代码写入0,20范围内的每个偶数和"有1个例外"两次.

我得到的是打印的一些数字(它们是ForAll的随机原因)然后抛出异常,但没有抓住并且程序停止.

我错过了什么吗？

最近在接受采访时,我得到了这个问题.

问:您是否编写过多线程应用程序？

答:是的

问:关心解释更多？

答:我用Tasks(任务并行库)来执行一些任务waiting for some info from internet while loading UI.这提高了我的应用程序可用性.

问:但是,您是否已经使用过TPL手段来编写multithreaded应用程序？

我:(不知道该说些什么1)

那么,什么是多线程应用程序呢？它与使用不同Tasks吗？

我有一个Web API的操作,我需要运行一些任务而忘记这个任务.这就是我的方法现在的组织方式:

public async Task<SomeType> DoSth()
{
    await Task.Run(...);
    .....
    //Do some other work
}

事情是,显然它停在等待线等待它完成后才继续工作.我需要"解雇并忘记"我是否应该在没有任何异步等待的情况下调用Task.Run()？