标签: task

我最近刚刚开始使用 CompletableFuture，但遇到了一个问题，我有 N 个请求待办事项。

每个请求应发送到 2 个不同的端点，并应比较 JSON 格式的结果。由于我有大量的请求待办事项，并且我不知道每个请求需要多长时间，因此我想限制等待结果的时间，例如 3 秒左右。

所以我写了这个测试代码：

public class MainTest {

   private static final Logger logger = LoggerFactory.getLogger(MainTest.class);
   private Instant start;

   public static void main(String[] args) {

       MainTest main = new MainTest();
       main.start();
   }

   public void start(){
       String req1 = "http://localhost:8080/testing";
       String req2 = "http://127.0.0.1:8095/testing2";

       ExecutorService exec = Executors.newCachedThreadPool();

       start = Instant.now();
       CompletableFuture<String> comp1 = CompletableFuture.supplyAsync(() -> doReq(req1), exec);
       CompletableFuture<String> comp2 = CompletableFuture.supplyAsync(() -> doReq(req2), exec);


       List<CompletableFuture<String>> completables = List.of(comp1,comp2);

       logger.info("Waiting completables");

       CompletableFuture<List<String>> a = …

请考虑以下代码段:

public static Task<string> FetchAsync()
{
    string url = "http://www.example.com", message = "Hello World!";

    var request = (HttpWebRequest)WebRequest.Create(url);
    request.Method = WebRequestMethods.Http.Post;

    return Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null)
        .ContinueWith(t =>
        {
            var stream = t.Result;
            var data = Encoding.ASCII.GetBytes(message);
            Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, data, 0, data.Length, null, TaskCreationOptions.AttachedToParent)
                .ContinueWith(t2 => { stream.Close(); });
        })
        .ContinueWith<string>(t =>
        {
            var t1 =
                Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null)
                .ContinueWith<string>(t2 =>
                {
                    var response = (HttpWebResponse)t2.Result;
                    var stream = response.GetResponseStream();
                    var buffer = new byte[response.ContentLength > 0 ? response.ContentLength : 0x100000]; …

(在任何人问之前,这不是功课.)

我有一组有兴趣的工人,即:

• Bob:Java,XML,Ruby

• 苏珊:Java,HTML,Python

• 弗雷德:Python,Ruby

• 山姆:Java,Ruby

• 等等

(对于每个工人,实际上在10-25"兴趣"的范围内,我有大约40-50名工人)

与此同时,我需要在工人之间分配大量的任务.每项任务必须分配给至少 3名工人,工人必须至少符合其中一项任务的利益:

任务1:Ruby,XML任务2:XHTML,Python

等等.所以鲍勃,弗雷德或萨姆可以得到任务1; 苏珊或弗雷德可以得到任务2.

这一切都存储在数据库中:

Task
    id integer primary key
    name varchar

TaskInterests
    task_id integer
    interest_id integer

Workers
    id integer primary key
    name varchar
    max_assignments integer

WorkerInterests
    worker_id
    interest_id

Assignments
    task_id
    worker_id
    date_assigned

每个工人的工作任务数量最多,大约为10个.有些利益比其他人更少见(即只有1或2个工人将其列为利息),有些利益更为普遍(即一半的工人列出他们的利益) ).

算法必须:

• 将每个任务分配给3名工作人员(假设至少有3名工人对该任务的一项兴趣感兴趣).
• 为每个工人分配1个或多个任务

理想情况下,算法将:

• 为每个工作人员分配与其最大分配和任务总数成比例的多个任务.例如,如果苏珊说她将完成20项任务,大多数人只完成10项任务,有50名工人和300项任务,则应分配12项任务(20/10*(300/50)).
• 为每个工作人员分配各种任务,因此如果Susan列出了4个兴趣,那么她将获得包含4个兴趣的任务(而不是获得10个具有相同兴趣的任务)

迄今为止最困难的方面是处理这些问题:

• 与少数相应工人有兴趣的任务
• 特别是兴趣不大的工人
• 有兴趣的工人,任务相对较少

这两个值来自TaskContinuationOptions枚举.我有点不确定使用哪一个.

另一对我感到困惑的是NotOnRanToCompletion和OnlyOnFaulted.

措辞对我来说有点混乱,每对中的每个值似乎都有相同的功能.我在这里错过了什么吗？

我需要在Global.asax中调用我的数据库上的一些异步操作.例如在Application_AuthenticateRequest中我需要针对数据库验证用户是否可以使用异步任务？

以下表格表示此问题涉及的应用程序中的工作流程.

我遇到OutOfMemory错误的问题,主要是因为用户能够多次从活动B切换到活动D(他们在每次尝试时显示不同的内容),而不会破坏先前的活动.这导致了一个非常大的backstack导致OutOfMemory错误.

为了避免这种情况,我遵循了建议,在清单中添加父活动,并使用TaskStackBuilder类创建新的backstack:

void openDFromB()
{
    Intent i = new Intent(this, ActivityD.class);
    TaskStackBuilder.create(this)
        .addParentStack(ActivityD.class)
        .addNextIntent(i)
        .startActivities();
}

如果用户现在从活动B切换到D,则销毁MainMenu,A和B并创建新的Backstack(MainMenu,C,D).这解决了api级别大10的内存问题,但不幸的是,TaskStackBuilder没有为pre api 11设备创建后台堆栈.

知道如何做以避免用户在api 11之前堆叠无限量的活动吗？这是否可能,或者我应该尝试在onPause中释放尽可能多的资源,以便在OoM之前获得最大量的堆叠活动？

提前致谢!

我试图了解在任务对象中引发但从未处理的异常发生了什么.

在MSDn上,据说:

如果您不等待传播异常的任务或访问其Exception属性,则在对任务进行垃圾回收时,将根据.NET异常策略升级异常.

所以我不太明白这些异常会以何种方式影响程序流程.我认为这些异常应该在垃圾收集后立即中断执行.但我无法设计这种行为.在以下代码段中,抛出的异常不会显示.

// Do something ...
Task.Run (()=> {throw new Exception("Exception in the task!");});
// Do something else

请问,任何人都可以解释如何处理未处理的任务异常,以及它们如何影响程序流程.

我有这个代码:

List<ComponentesClasificaciones> misClasificaciones = new List<ComponentesClasificaciones>();
            Task tskClasificaciones = Task.Run(() =>
                {
                    misClasificaciones = VariablesGlobales.Repositorio.buscarComponentesClasificacionesTodosAsync().Result;
                });

Task.WhenAll(tskClasificaciones);

List<ComponentesClasificaciones> misVClasificacionesParaEstructuras = new List<ComponentesClasificaciones>(misClasificaciones);

如果我使用Task.WhenAll,misClasificaciones没有任何元素,但是当我使用awit时,我得到了我向数据库请求的所有元素.

何时使用WhenAll以及何时使用WaitAll？

我最近从Visual Studio 2013切换到2015并转换了所有旧项目.但是,现在我似乎无法再找到我的用户任务了？在任务列表中曾经有一个下拉菜单,但看起来它已经在新版本中消失了,除非我遗漏了一些东西.

是否删除了用户任务？如果是这样,有没有办法我仍然可以从我的项目中检索它们？

这是中提到的Spring文档是:

ThreadPoolTaskScheduler实际上也实现了Spring的TaskExecutor接口,因此单个实​​例可以尽快用于异步执行,也可以用于计划和可能重复执行.

那么我们想要在ThreadPoolTaskExecutor实例上使用实例的场景是哪些ThreadPoolTaskScheduler？

我目前正在使用Spring XML.我正在创建ThreadPoolTaskScheduler如下bean :

<task:scheduler id="myScheduler" pool-size="1"/>

而ThreadPoolTaskExecutor实例的bean 可以创建为

<task:executor id="executor" pool-size="10"/>