我有Loop生成任务.
码:
Task task = null;
foreach (Entity a in AAAA)
{
// create the task
task = new Task(() => {
myMethod(a);
}, Token, TaskCreationOptions.None);
task.Start();
}
Run Code Online (Sandbox Code Playgroud)
正如你在每次迭代中看到的那样,任务对象有了新的初始化(.. new Task(()=> ..)我怎么知道所有的任务都完成了?
假设应用程序已经有一堆活动,然后使用FLAG_ACTIVITY_NEW_TASK从应用程序上下文启动一个新活动.这发生在同一个进程中,即在应用程序内部,如下所示:
AppContext -> A(FLAG_ACTIVITY_NEW_TASK) -> B -> C; AppContext -> D(FLAG_ACTIVITY_NEW_TASK)
Run Code Online (Sandbox Code Playgroud)
根据文档,我们现在有2个任务:
Task 1: A, B, C; Task 2: D
Run Code Online (Sandbox Code Playgroud)
从文档中可以看出,用户理论上可以独立地切换到活动C或活动D,因为它们属于不同的任务.然而,在实践中,我无法切换到活动C - 它总是切换到D.
我的问题是: 如果在与FLAG_ACTIVITY_NEW_TASK相同的过程中启动,任务是不是独立的,用户只能切换到最顶层任务中的最顶层活动?
如果答案是"否",那么用户切换到任务1的方式是什么?
答案是:否
任务是独立的,用户可以独立切换他们的活动,有效地将您的应用程序的两个活动放在堆栈顶部.在询问原始问题三年后,我刚刚找到了用例.
我们的应用程序将自己注册为URL方案的处理程序(如market://xxx.yyy/zzz).现在让我们想象一下,用户使用启动器启动了应用程序,进入某事物(活动A, B, C)的中间,然后离开了.然后在浏览器中,用户单击URL以启动我们的其他活动(活动D).这导致在同一时间有两个任务:活动A, B, C(C在顶部)和活动D.用户可以通过任务历史在这两个活动之间切换.
有趣的是,使用应用程序自己的图标在任务历史记录中可以看到活动C,但是使用浏览器的图标可以看到活动D. 无论如何,两者都可以切换到.
此外,这两个任务A-B-C,并D在同一个进程中运行.这意味着所有单重对象和静态数据都在它们之间共享.因此,如果不采取谨慎措施,他们可能会破坏彼此的状态.
假设我有一个处理器,他的工作就是将文件保存回磁盘.这是Task在观察BlockingCollection<T>要处理的文件的同时运行.
当任务被取消并且仍然存在应该保存到磁盘的文件时,这样做的好习惯是什么?
尽管我不确定这是否与取消任务的理念相冲突(因为取消应该尽可能快地发生),但是在退出之前让任务正确并将剩余的文件快速写回磁盘是很方便的.
另一个选择是在取消任务之后执行第二个过程,其任务是将剩余文件写入磁盘.
代码示例:
class FileProcessor
{
private readonly BlockingCollection<Stream> input;
public FileProcessor(BlockingCollection<Stream> input)
{
_input = input;
}
public Task Run(CancellationToken cancellationToken,
BlockingCollection<Stream> input)
{
return Task.Factory.StartNew(() =>
{
foreach (Stream stream in
input.GetConsumingEnumerable(cancellationToken))
{
WriteToDisk(stream);
}
// Should I call WriteRemaining here or should I have
// a process running after this task exited which
// will call WriteRemaining
WriteRemaining();
});
}
public void WriteRemaining()
{
foreach (Stream stream in input)
{
WriteToDisk(stream); …Run Code Online (Sandbox Code Playgroud) 任何人都可以解释为什么这个片段:
// Create required tasks
foreach (var messageToSend in messagesToSend)
{
EmailMessage messageToBeSent = messageToSend;
Task<bool> processingTask = new Task<bool>(() => SendMessage(messageToBeSent));
processingTask.Start();
}
Run Code Online (Sandbox Code Playgroud)
与此不同的是:
// Create required tasks
foreach (var messageToSend in messagesToSend)
{
Task<bool> processingTask = new Task<bool>(() => SendMessage(messageToSend));
processingTask.Start();
}
Run Code Online (Sandbox Code Playgroud)
在第一个片段中,所有任务都以自己的消息开头,而在第二个片段中,所有任务都以相同的消息开头?
Resharper给出了这样的描述:"在关闭时访问foreach变量.使用不同版本的编译器编译时可能会有不同的行为." 为什么它会有不同的行为?
在阅读有关任务和exepcion管理的信息后,我使用此代码来管理任务中抛出的异常:
Task<Object> myTask = Task.Factory.StartNew<Object>(doTask, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
myTask .ContinueWith(task => afterTask(task), TaskScheduler.FromCurrentSynchronizationContext());
Run Code Online (Sandbox Code Playgroud)
doTask和AfterTask在哪里:
private <Object> doTask() {
throw new Exception("BOOM");
}
private afterTask(Task<Object> aTask) {
if (aTask.IsFaulted)
{
MessageBox.Show(aTask.Exception.InnerException.Message);
}
else //whatever
}
Run Code Online (Sandbox Code Playgroud)
抛出Exception Boom时,Visual Studio会显示一条警告,通知未捕获异常但如果我继续执行异常则在afterTask函数中处理.
这段代码是正确的还是我错过了解任务的一些基本行为?有什么办法可以避免调试器发出没有捕获到execption的警告?有点烦人......
提前致谢
我手动构建一个任务:
var task = new Task(() =>
Debug.WriteLine("Task"));
Run Code Online (Sandbox Code Playgroud)
然后手动启动它:
task.Start(TaskScheduler.FromCurrentSynchronizationContext());
Run Code Online (Sandbox Code Playgroud)
我希望它能通过预定SynchronizationContext.Post.
但如果以这种方式启动它:
task.RunSynchronously(TaskScheduler.FromCurrentSynchronizationContext());
Run Code Online (Sandbox Code Playgroud)
是通过SynchronizationContext.Send调用任务的lambda 来执行还是直接执行?
我想在Gradle中进行功能测试时自动添加serverRun任务,所以我添加了一个依赖项:
funcTestTask.dependsOn(serverRun)
Run Code Online (Sandbox Code Playgroud)
无论funcTestTask是否运行,都会导致任务运行
:compile
:serverRun
:funcTestTask (and associate compile tasks... etc)
:serverStop
OR
:compile UP-TO-DATE
:serverRun <-- unnecessary
:funcTestTask UP-TO-DATE
:serverStop
Run Code Online (Sandbox Code Playgroud)
启动服务器的成本非常高,我只想在FunctionalTest 不是 UP-TO-DATE时启动它,我想做什么或者其他什么:
if(!funcTestTask.isUpToDate) {
funcTestTask.dependsOn(serverRun)
}
Run Code Online (Sandbox Code Playgroud)
所以我知道我不知道funcTestTask的最新状态,直到它的所有输入/输出被确定但是我可以继承它的uptoDate检查器吗?
serverRun.outputs.upToDateWhen(funcTestTask.upToDate)
Run Code Online (Sandbox Code Playgroud)
替代方案是在FuncTest中"doFirst"ServerRun,我认为这通常不赞成?
funcTestTask.doFirst { serverRun.execute() }
Run Code Online (Sandbox Code Playgroud)
有没有办法在另一个之前有条件地运行任务?
更新1
尝试设置输入/输出相同
serverRun.inputs.files(funcTestTask.inputs.files)
serverRun.outputs.files(funcTestTask.outputs.files)
Run Code Online (Sandbox Code Playgroud)
这似乎重新运行服务器重新编译(好),跳过重新运行成功未更改的功能测试(也很好),但不会重新运行测试失败的测试,如下所示
:compile
:serverRun
:funcTestTask FAILED
then
:compile UP-TO-DATE
:serverRun UP-TO-DATE <-- wrong!
:funcTestTask FAILED
Run Code Online (Sandbox Code Playgroud) 我在新的Android API 21中使用JobScheduler的作业计划有问题.这是我用60秒间隔调度作业的代码,如下所示:
ComponentName serviceName = new ComponentName(this, MyJobService.class);
JobInfo jobInfo = new JobInfo.Builder(0, serviceName)
.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
.setPeriodic(60000)
.build();
Run Code Online (Sandbox Code Playgroud)
我的JobService只在Logcat中打印运行时,但是日志显示服务在这个时刻运行:
03-18 08:37:26.334: I/JOB(32662): Wed Mar 18 08:37:26 BRT 2015
03-18 08:37:56.364: I/JOB(32662): Wed Mar 18 08:37:56 BRT 2015
03-18 08:39:21.418: I/JOB(32662): Wed Mar 18 08:39:21 BRT 2015
03-18 08:41:51.670: I/JOB(32662): Wed Mar 18 08:41:51 BRT 2015
03-18 08:45:52.192: I/JOB(32662): Wed Mar 18 08:45:52 BRT 2015
03-18 08:54:20.678: I/JOB(32662): Wed Mar 18 08:54:20 BRT 2015
Run Code Online (Sandbox Code Playgroud)
这很奇怪,因为我用setPeriodic(60000)方法设置它应该在1分钟内执行至少1次.同样好奇的是如何在运行之间增加间隔.此时的时间是2015年3月18日星期三09:09:00 BRT 2015并且工作不会被执行更多.
这是JobScheduler API的问题吗?(我在Android 5.0.1的Nexus 5中运行)
我试图通过在代码中执行它来理解并发性.我有一个代码片段,我认为它是异步运行的.但是当我把调试writeline语句放入其中时,我发现它正在同步运行.有人可以解释我需要做什么不同的使用Task.Something将ComputeBB()推送到另一个线程?
澄清 我想让这段代码在其他一些线程中运行ComputeBB,这样主线程就会继续运行而不会阻塞.
这是代码:
{
// part of the calling method
Debug.WriteLine("About to call ComputeBB");
returnDTM.myBoundingBox = await Task.Run(() => returnDTM.ComputeBB());
Debug.WriteLine("Just called await ComputBB.");
return returnDTM;
}
private ptsBoundingBox2d ComputeBB()
{
Debug.WriteLine("Starting ComputeBB.");
Stopwatch sw = new Stopwatch(); sw.Start();
var point1 = this.allPoints.FirstOrDefault().Value;
var returnBB = new ptsBoundingBox2d(
point1.x, point1.y, point1.z, point1.x, point1.y, point1.z);
Parallel.ForEach(this.allPoints,
p => returnBB.expandByPoint(p.Value.x, p.Value.y, p.Value.z)
);
sw.Stop();
Debug.WriteLine(String.Format("Compute BB took {0}", sw.Elapsed));
return returnBB;
}
Run Code Online (Sandbox Code Playgroud)
以下是即时窗口中的输出:
About to call ComputeBB
Starting ComputeBB.
Compute BB …Run Code Online (Sandbox Code Playgroud) 这就是我的意思:
public Task<SomeObject> GetSomeObjectByTokenAsync(int id)
{
string token = repository.GetTokenById(id);
if (string.IsNullOrEmpty(token))
{
return Task.FromResult(new SomeObject()
{
IsAuthorized = false
});
}
else
{
return repository.GetSomeObjectByTokenAsync(token).ContinueWith(t =>
{
t.Result.IsAuthorized = true;
return t.Result;
});
}
}
Run Code Online (Sandbox Code Playgroud)
可以等待上述方法,我认为它与基于T的A同步P模式建议的操作非常相似?(我知道的其他模式是APM和EAP模式。)
现在,下面的代码呢?
public async Task<SomeObject> GetSomeObjectByToken(int id)
{
string token = repository.GetTokenById(id);
if (string.IsNullOrEmpty(token))
{
return new SomeObject()
{
IsAuthorized = false
};
}
else
{
SomeObject result = await repository.GetSomeObjectByTokenAsync(token);
result.IsAuthorized = true; …Run Code Online (Sandbox Code Playgroud)