Hacker News Reader

Comment by mgraczyk | Hacker News Reader

Something like this should work, no? Only run the coroutine if you won the race.

    D = {}
    async def maybe_initialize():
        global D
        this_setup = asyncio.ensure_future(one_time_setup())
        actual_setup = D.setdefault('initializer', this_setup)
        if this_setup is not actual_setup:
          this_setup.cancel()
        await actual_setup
        return

complete example: https://gist.github.com/mgraczyk/e251443bccfe54505e75b652655...

View on HN

I think something might be off in your mental model of python coroutines. They work via cooperative multitasking. Atomic operations aren't really necessary or relevant in such a system where you are in complete control of all yield points (i.e., calls to `await`).

If you read the full blog post, the author solves the problem without setdefault, and without having to cancel any futures.

I understand them quite well, thank you. You don't need setdefault if you only call the initializer from one thread. My code can be made thread safe (as long as you only use one event loop per thread).

It's way easier with a single thread. You don't need a lock or atomic operations.

    initializer = None
    async def maybe_initialize():
      global initializer
      if initializer is None:
        initializer = asyncio.ensure_future(one_time_setup())
      await initializer
      return

This is the same as the solution from the article, except that:

- Chris forgot to declare the variable as global;

- Chris used asyncio.create_task() instead of asyncio.ensure_future().

Maybe it's me not grokking async, but the code seems right to me. `once` is a decorator, so `future` is "instantiated" once per decorated function, which is then accessed as nonlocal in the wrapper. So in the last code sample, every call to `one_time_setup()` is accessing the same `future`.

Thanks for pointing that out, for some reason I had thought the last implementation also used a lock.

(Chris has added the global declaration since then.)

Since D is not being rebound, the global declaration is unneeded.

You have to make it clear you’re speaking of CPU atomics, because whatever atomic operations are trying to solve, for example mainly “read then write” operations - may still easily cause issues within asynchronous code.

A small point: since you're not rebinding D, you don't need the "global" declaration.

Reply on news.ycombinator.com