Data racing when using BINARY_OP and async functions

[yanyongyu]

Bug report

Bug description:

I have encountered some racing issue when using binary_op and async functions like this:

import asyncio

result = 0


async def some_func(data: int):
    await asyncio.sleep(1)
    return data


async def test(data: int):
    global result

    result += await some_func(data)


async def main():
    tasks = [asyncio.create_task(test(i)) for i in range(10)]
    await asyncio.gather(*tasks)

    print(result)


asyncio.run(main())

In the test function, a binary operation (addition) is performed on the global variable result. Multiple tasks may attempt to read and update the value of result. But, it seems the binary_op += load_global result first and then await the right-side value. The atomicity of the addition binary operation is not guaranteed. This causes the data override.

This issue also occurred when using dict, update the dict value and some other cases.

Example

import asyncio

result = {"value": 0}


async def some_func(data: int):
    await asyncio.sleep(1)
    return data


async def test(data: int):
    result["value"] += await some_func(data)


async def main():
    tasks = [asyncio.create_task(test(i)) for i in range(10)]
    await asyncio.gather(*tasks)

    print(result)


asyncio.run(main())

I'm not sure if this operation is as-designed or if this is documented behavior. Maybe this error case should be highlighted in the documentation.

cc @RF-Tar-Railt, @ProgramRipper

CPython versions tested on:

3.12, 3.13

Operating systems tested on:

Linux

[chenxuan353]

Can also be reproduced when passed as a parameter

import asyncio
async def some_func(data: int):
    await asyncio.sleep(1)
    return data

async def test(result: dict, data: int):
    result["value"] += await some_func(data)

async def main():
    result = {"value": 0}
    tasks = [asyncio.create_task(test(result, i)) for i in range(10)]
    await asyncio.gather(*tasks)

    print(result)

asyncio.run(main())

[JelleZijlstra]

This behavior is documented in the language reference (https://docs.python.org/3/reference/simple_stmts.html#augmented-assignment-statements):

Unlike normal assignments, augmented assignments evaluate the left-hand side before evaluating the right-hand side. For example, a[i] += f(x) first looks-up a[i], then it evaluates f(x) and performs the addition, and lastly, it writes the result back to a[i].

You get a data race because you first read, then await (giving other tasks an opportunity to run), then write. To avoid data races in asyncio code, you cannot await inside the augmented assignment. Instead, first compute your result and then mutate the global:

value = await some_func(data)
result += value