Goroutines in Scheme

Goroutines in Python#

A goroutine is a lightweight thread of execution. Here’s how you can achieve similar concurrency in Python using threads.

import threading
import time

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

if __name__ == "__main__":
    # Calling the function directly
    f("direct")

    # Calling the function asynchronously using a thread
    threading.Thread(target=f, args=("thread",)).start()

    # Using anonymous function (lambda) in a thread
    threading.Thread(target=lambda: print("going")).start()

    # Wait for the threads to finish
    time.sleep(1)
    print("done")

Suppose we have a function that prints a message. Here’s how we would call it in the usual way, running it synchronously.

f("direct")

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

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 join method on threads).

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 interpreter.

$ 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: async programming with asyncio.