Goroutines in Python

A *goroutine* is a lightweight thread of execution.

```python
import time

def f(from_str):
    for i in range(3):
        print(f"{from_str} : {i}")

def main():
    # Call `f` synchronously
    f("direct")
    
    # Invoke `f` in a thread
    import threading
    threading.Thread(target=f, args=("thread",)).start()
    
    # Start a thread for an anonymous function
    threading.Thread(target=lambda: print("going")).start()
    
    # Wait for a moment to allow threads to finish
    time.sleep(1)
    print("done")

if __name__ == "__main__":
    main()

Suppose we have a function call f(s). Here’s how we’d call that in the usual way, running it synchronously.

f("direct")

To invoke this function in a thread, we can use the threading module. This new thread will execute concurrently with the calling one.

import threading
threading.Thread(target=f, args=("thread",)).start()

You can also start a thread for an anonymous function call.

threading.Thread(target=lambda: print("going")).start()

Our two function calls are running asynchronously in separate threads now. Wait for them to finish (for a more robust approach, use a threading.Event or another synchronization primitive).

time.sleep(1)
print("done")

When we run this program, we see the output of the blocking call first, then the output of the two threads. The threads’ output may be interleaved because threads are being run concurrently by the Python runtime.

$ python goroutines.py
direct : 0
direct : 1
direct : 2
thread : 0
going
thread : 1
thread : 2
done

Next, we’ll look at a complement to threads in concurrent Python programs: asyncio.