标签: task

.NET 4有一个Class - Task.这很有趣,我想开始使用它.例如,我想创建一个非常简单的基于任务的文件下载器,可以在每次下载时取消.任何人都可以向我介绍一些这样做的示例代码吗？我想有一个正在运行的任务列表,并希望能够取消它们中的任何一个.

PS Code示例可能无法正常运行我只想知道如何以最佳方式使用这些东西.

我有一个按钮,可以产生4个任务.相同的按钮更改为取消按钮,单击此按钮将取消所有4个任务.我是否应该将相同的取消令牌传递给所有4个任务并让他们对IsCancelRequested的相同令牌进行轮询？在createlinkedtokensource上阅读msdn doc后我很困惑.这通常是怎么做的？谢谢

更新:Task.WaitAll()等待所有任务完成执行.类似地,一旦共享取消令牌源设置为取消,如何知道何时取消所有任务.

我知道Rake任务可以在Ruby gem中的许多地方定义:

• 在Rakefile里面
• 内 tasks/*.rake
• 内 lib/tasks/*.rake

我已经读过,当要在gem本身执行任务时,应该使用前两个.当希望公开任务时,似乎应该选择第三种选择.

网上有很多教程演示了使用Rails从gem加载Rake任务的各种方法,即利用Rails::RailTie.

但是,我想找到一种在不需要Rails的情况下在另一个gem中使用依赖gem的任务的方法.

有一个简单的解决方案吗？有人会善意地描述正确的方法,或概述哪些方法可行？

UPDATE

我已经尝试创建一个文件bin/my-gem,以便在系统上用于执行Rake任务my-gem.我把以下内容放在里面;

#!/usr/bin/env ruby
require 'rubygems'
require 'rake'
task=ARGV[0]
spec = Gem::Specification.find_by_name('dsi_core')
Dir["#{spec.gem_dir}/lib/tasks/*.rake"].each {|file| puts file and Rake::load_rakefile(file)}
Rake::Task.clear # Avoid tasks being loaded several times in dev mode
Rake::Task[task].reenable # Support re-execution of a task.
Rake::Task[task].invoke

部分内容基于此SO帖子.

可悲的是我,因为在安装宝石,然后运行做错事my-gem mytask与mytask定义lib/test.rake再下面是输出:

/var/lib/gems/1.8/gems/rake-0.9.2/lib/rake/task_manager.rb:49:in `[]': Don't know how to build task 'mytest' (RuntimeError)
    from /var/lib/gems/1.8/gems/rake-0.9.2/lib/rake/task.rb:298:in `[]'
    from /var/lib/gems/1.8/gems/my_gem-0.0.1/bin/my_gem:8 …

我正在将一个流浪汉配置者从shell转换为ansible,我想知道是否有任何选项可以显示完成每项任务所需的实际时间？

理想情况下,我想使用shell:方法和内置的yum:with_items方法来测量在yum中安装多个包之间的区别.ATM我坐在这里有一个秒表,但我需要准确的时间.

我团队中有些人非常喜欢使用异步编码Task.有时他们喜欢使用CancellationToken参数.

我不确定的是我们作为一个团队是否应该使用这种代码风格(A):

async Task<someObject> DoStuff(CancellationToken t)
{
    while (!t.IsCanceled)
    {
        try {
            Task.Delay(5000, t);
        }
        catch (AggregateException e) // or is it TaskCanceledException or OperationCanceledException? I don't know? :)
        {
        }
        // poll something, return someObject, or null
    }
    return null;
}

这显然意味着调用者可能必须自己检查取消令牌以确定是否继续处理,并且他们可能必须处理null retVals:

var retVal = await DoStuff(token);
if (token.IsCanceled) { ... }

但是,如果我们采用依赖于TaskCanceledException的第二种代码(B):

async Task<someObject> DoStuff(CancellationToken t)
{
    while(true)
    {
        Task.Delay(5000, t);
        // poll something, return someObject, or null
    }
}

实现代码肯定更简单 - 调用者可以选择是否处理异常,但是我不禁担心调用者可能会 …

我一直在阅读python 3中的asyncio模块,更广泛地讲述python中的协同程序,我无法得到使asyncio成为如此优秀工具的原因.我觉得你可以用协同程序做所有事情,你可以通过使用基于多处理模块的任务队列(例如芹菜)来做得更好.是否存在协同程序优于任务队列的用例？

无论taskB mustRunAfter taskA,还是taskB dependsOn taskA,似乎taskA先运行,然后taskB运行.有什么不同？

我想知道在使用TPL TaskFactory.FromAsync和使用TaskFactory.StartNew阻塞版本的方法之间是否存在性能影响.我正在编写一个TCP服务器,它将支持不超过100个并发连接.在使用第一个选项编写代码并使用continue来链接多个读写操作之后,我留下了丑陋,难以调试的代码.

我相信用同步版本编写代码然后用Task包装它会降低复杂性并提高可测试性,但是我担心这样做的性能影响.

例如,这两个调用之间是否存在任何性能差异:

NetworkStream stream;
byte[] data;
int bytesRead;

//using FromAsync
Task<int> readChunk = Task<int>.Factory.FromAsync (
      stream.BeginRead, stream.EndRead,
      data, bytesRead, data.Length - bytesRead, null);

//using StartNew with blocking version
Task<int> readChunk2 = Task<int>.Factory.StartNew(() => 
      stream.Read(data, bytesRead, data.Length - bytesRead));

我有一个spark作业,它接收来自hdfs的8条记录的文件,做一个简单的聚合并将其保存回hdfs.当我这样做时,我注意到有数百个任务.

我也不确定为什么有这么多工作？我觉得工作更像是一个动作发生的时候.我可以推测为什么 - 但我的理解是,在这段代码中它应该是一个工作,它应该分解为阶段,而不是多个工作.为什么不把它分解成各个阶段,为什么它会闯入工作岗位？

至于200多个任务,由于数据量和节点数量微乎其微,当只有一个聚合和几个过滤器时,每行数据有25个任务是没有意义的.为什么每个原子操作每个分区只有一个任务？

这是相关的scala代码 -

import org.apache.spark.sql._
import org.apache.spark.sql.types._
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf

object TestProj {object TestProj {
  def main(args: Array[String]) {

    /* set the application name in the SparkConf object */
    val appConf = new SparkConf().setAppName("Test Proj")

    /* env settings that I don't need to set in REPL*/
    val sc = new SparkContext(appConf)
    val sqlContext = new SQLContext(sc)
    import sqlContext.implicits._

    val rdd1 = sc.textFile("hdfs://node002:8020/flat_files/miscellaneous/ex.txt")

     /*the below rdd will have schema defined in Record class*/
     val rddCase = …

我想我明白了async/ await和Task.Run()相当好,直到我来到这个问题:

我编程使用一个Xamarin.Android应用RecyclerView了ViewAdapter.在我的OnBindViewHolder方法中,我尝试异步加载一些图像

public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
{
    // Some logic here

    Task.Run(() => LoadImage(postInfo, holder, imageView).ConfigureAwait(false)); 
}

然后,在我的LoadImage函数中,我做了类似的事情:

private async Task LoadImage(PostInfo postInfo, RecyclerView.ViewHolder holder, ImageView imageView)
{                
    var image = await loadImageAsync((Guid)postInfo.User.AvatarID, EImageSize.Small).ConfigureAwait(false);
    var byteArray = await image.ReadAsByteArrayAsync().ConfigureAwait(false);

    if(byteArray.Length == 0)
    {
        return;
    }

    var bitmap = await GetBitmapAsync(byteArray).ConfigureAwait(false);

    imageView.SetImageBitmap(bitmap);
    postInfo.User.AvatarImage = bitmap;
}

这段代码有效.但为什么？

我所学到的,在configure await设置为false之后,代码不会在SynchronizationContext(它是UI线程)中运行.

如果我使 …