C# Task.WaitAll()如何将对象状态合并为一个？

Question

C# Task.WaitAll()如何将对象状态合并为一个？

c#asynchronousasync-awaittask-parallel-librarytask

6

以一个简单的酒店实体为例：

class Hotel
{
    public int NumberOfRooms { get; set; }
    public int StarRating { get; set; }
}

请考虑以下C# 5.0代码：

public void Run()
{
    var hotel = new Hotel();
    var tasks = new List<Task> { SetRooms(hotel), SetStars(hotel) };
    Task.WaitAll(tasks.ToArray());
    Debug.Assert(hotel.NumberOfRooms.Equals(200));
    Debug.Assert(hotel.StarRating.Equals(5));
}

public async Task SetRooms(Hotel hotel)
{
    await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
    hotel.NumberOfRooms = 200;
}

public async Task SetStars(Hotel hotel)
{
    await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
    hotel.StarRating = 5;
}

两次对Debug.Assert()的调用都成功了。我不明白的是，在两个任务都完成之后，Hotel实例如何包含来自并行运行的两种方法的分配。

我原以为当调用await（在SetRooms()和SetStars()中）时，会创建一个酒店实例的“快照”（其中NumberOfRooms和StarRating均设置为0）。所以我的期望是两个任务之间会出现竞争条件，并且最后一个运行的任务将被复制回hotel，导致其中一个属性为0.

显然，我错了。您能解释一下我在await工作方面的误解吗？

- urig

1

你从哪里得到“快照”这个概念的想法呢？ :) - Yacoub Massad

从编译器创建的状态机的描述中我猜测...？:( - urig

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Yuval Itzchakov · Accepted Answer

我认为在SetRooms()和SetStars()中调用await时，会创建一个酒店实例的“快照”。

你的Hotel类是引用类型。当使用异步等待时，方法将转换为状态机，并且该状态机将变量的引用提升到其中。这意味着创建的两个状态机都指向同一个Hotel实例。没有你的Hotel的“快照”或深层复制，编译器不会这样做。

如果您想了解实际发生的情况，您可以查看编译器在转换异步方法后发出的内容:

[AsyncStateMachine(typeof(C.<SetRooms>d__1))]
public Task SetRooms(Hotel hotel)
{
    C.<SetRooms>d__1 <SetRooms>d__;
    <SetRooms>d__.hotel = hotel;
    <SetRooms>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
    <SetRooms>d__.<>1__state = -1;
    AsyncTaskMethodBuilder <>t__builder = <SetRooms>d__.<>t__builder;
    <>t__builder.Start<C.<SetRooms>d__1>(ref <SetRooms>d__);
    return <SetRooms>d__.<>t__builder.Task;
}
[AsyncStateMachine(typeof(C.<SetStars>d__2))]
public Task SetStars(Hotel hotel)
{
    C.<SetStars>d__2 <SetStars>d__;
    <SetStars>d__.hotel = hotel;
    <SetStars>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
    <SetStars>d__.<>1__state = -1;
    AsyncTaskMethodBuilder <>t__builder = <SetStars>d__.<>t__builder;
    <>t__builder.Start<C.<SetStars>d__2>(ref <SetStars>d__);
    return <SetStars>d__.<>t__builder.Task;
}

你可以看到，两种方法都将hotel变量提升到它们的状态机中。

引用：我的期望是两个任务之间会存在竞争条件，最后一个运行的任务将被复制回到hotel中，导致其中一个属性为0。

现在你看到编译器实际上做了什么，你就能理解真正没有竞争条件。正在修改的是相同的Hotel实例，每个方法设置了不同的变量。

顺便提一下

也许您只是编写此代码作为示例来解释您的问题，但如果您已经创建了异步方法，我建议使用Task.WhenAll而不是阻塞的Task.WaitAll。这意味着将Run的签名更改为async Task而不是void：

public async Task RunAsync()
{
    var hotel = new Hotel();
    await Task.WhenAll(SetRooms(hotel), SetStars(hotel));
    Debug.Assert(hotel.NumberOfRooms.Equals(200));
    Debug.Assert(hotel.StarRating.Equals(5));
}