Asyncio - 비동기 프로그래밍

 

주요 개념

파이썬의 asyncio 모듈은 비동기 I/O, 이벤트 루프, coroutines 및 태스크(task) 관리 등을 통해 비동기 프로그래밍을 지원하는 표준 라이브러리입니다. asyncio를 사용하면 네트워크 및 웹 소켓, 데이터베이스, 파일 I/O 등의 작업을 효율적으로 처리할 수 있습니다.

1. 이벤트 루프 (Event Loop):
   • 이벤트 루프는 코루틴과 콜백을 관리하고, I/O 작업이 완료될 때까지 기다리는 역할을 합니다.
   • asyncio.run() 함수를 통해 이벤트 루프를 시작할 수 있습니다.
2. 코루틴 (Coroutine):
   • async def로 정의된 함수입니다.
   • await 키워드를 사용하여 다른 코루틴이나 비동기 작업을 기다립니다.
3. 태스크 (Task):
   • 코루틴을 이벤트 루프에서 실행할 수 있는 단위로 변환합니다.
   • asyncio.create_task()를 사용하여 태스크를 생성하고, 이를 통해 여러 코루틴을 동시에 실행할 수 있습니다.
4. 퓨처 (Future):
   • 비동기 연산의 결과를 나타냅니다.
   • 코루틴이나 태스크의 결과를 표현할 때 사용됩니다.

 

주요 함수 및 사용법

이벤트 루프 실행

import asyncio

async def main():
    print("Hello, asyncio!")

# 이벤트 루프 실행
asyncio.run(main())

코루틴 정의 및 실행

import asyncio

async def say_hello():
    print("Hello!")
    await asyncio.sleep(1)
    print("Goodbye!")

async def main():
    await say_hello()

asyncio.run(main())

태스크 생성 및 실행

import asyncio

async def say_after(delay, message):
    await asyncio.sleep(delay)
    print(message)

async def main():
    task1 = asyncio.create_task(say_after(1, "Hello"))
    task2 = asyncio.create_task(say_after(2, "World"))

    await task1
    await task2

asyncio.run(main())

 

 

고급 기능

여러 태스크 동시에 실행

import asyncio

async def say_hello():
    await asyncio.sleep(1)
    print("Hello!")

async def say_goodbye():
    await asyncio.sleep(2)
    print("Goodbye!")

async def main():
    await asyncio.gather(say_hello(), say_goodbye())

asyncio.run(main())

타임아웃 설정

import asyncio

async def long_running_task():
    await asyncio.sleep(5)
    return "Completed"

async def main():
    try:
        result = await asyncio.wait_for(long_running_task(), timeout=3)
        print(result)
    except asyncio.TimeoutError:
        print("Task timed out")

asyncio.run(main())

비동기 I/O 작업

import asyncio

async def read_file(file_path):
    loop = asyncio.get_event_loop()
    with open(file_path, 'r') as file:
        data = await loop.run_in_executor(None, file.read)
    return data

async def main():
    content = await read_file('example.txt')
    print(content)

asyncio.run(main())

 

요약

asyncio는 파이썬에서 비동기 프로그래밍을 쉽게 구현할 수 있도록 다양한 도구와 기능을 제공합니다. 이벤트 루프를 통해 코루틴과 태스크를 관리하고, 네트워크와 파일 I/O 같은 비동기 작업을 효율적으로 처리할 수 있습니다. 이를 통해 응답성이 높고 자원을 효율적으로 사용하는 프로그램을 작성할 수 있습니다.

 

✔️여기까지가 웹 페이지 및 GPT의 도움을 받은 포스팅입니다.

---

✔️ 여기부터는 강의를 통해 학습한 내용 정리입니다.

 

개요

import asyncio
import time

async def sleep():
	await asyncio.sleep(1)
	
async def sum(name, numbers):
  start = time.time()
  total = 0
    
	for number in numbers:
		await sleep()
    total += number
    print(f'작업중={name}, number={number}, total={total}')
  end = time.time()
  print(f'작업명={name}, 걸린시간={end-start}')
  
	return total

async def main():
  start = time.time()

	task1 = asyncio.create_task(sum("A", [1, 2]))
	task2 = asyncio.create_task(sum("B", [1, 2, 3]))
	
	await task1
	await task2
	
	result1 = task1.result()
	result2 = task2.result()

  end = time.time()
  print(f'총합={result1+result2}, 총시간={end-start}')

if __name__ == "__main__":
	asyncio.run(main())

함수를 비동기로 호출하려면 이렇게 def 앞에 async라는 키워드를 넣으면 된다. 그러면 이제 이 함수는 비동기 함수가 된다. 이때 async를 적용한 비동기 함수를 코루틴이라 부른다.

또한, 코루틴 안에서 다른 코루틴을 호출할 때는 await sleep()과 같이 await를 함수명 앞에 붙여 호출해야 한다. 코루틴 수행 중 await 코루틴을 만나면 await로 호출한 코루틴이 종료될 때까지 기다리지 않고 제어권을 메인 스레드나 다른 코루틴으로 넘긴다. 이러한 방식을 넌블록킹(non-blocking)이라 한다. 그리고 호출한 코루틴이 종료되면 이벤트에 의해 다시 그 이후 작업이 수행된다.

여기서 하나 눈여겨봐야 할 점은 sleep() 함수에서 time.sleep(1) 대신 asyncio.sleep(1)를 사용한 부분이다. 코루틴이 아닌 time.sleep(1)을 사용한다면 await가 적용되지 않아 실행 시간을 줄일 수 없다.

main() 함수에서 사용한 asyncio.create_task()는 수행할 코루틴 작업(태스크)을 생성한다. 여기서는 작업을 생성할 뿐이지 실제로 코루틴이 수행되는 것은 아니다. 실제 코루틴 실행은 await 태스크가 담당한다. 그리고 실행 태스크의 결괏값은 태스크.result()로 얻을 수 있다.

asyncio.create_task()는 코루틴을 동시에 실행하는 데 꼭 필요하다. 다음처럼 태스크가 아닌 await로 코루틴을 실행한다면 코루틴이 동시에 실행되지 않고 하나씩 차례로 실행되어 이득이 없을 것이다.

result1 =await sum("A", [1, 2])
result2 =await sum("B", [1, 2, 3])

asyncio.run(main())은 런 루프를 생성하여 main() 코루틴을 실행한다. 코루틴을 실행하려면 런 루프가 반드시 필요하다. 코루틴이 모두 비동기적으로 실행되기 때문에 그 시작과 종료를 감지할 수 있는 이벤트 루프가 반드시 필요하기 때문이다.

이 코드를 실행한 결과는 다음과 같다.

c:\\projects\\pylib>python asyncio_sample.py
작업중=A, number=1, total=1
작업중=B, number=1, total=1
작업중=A, number=2, total=3
작업명=A, 걸린시간=2.000617742538452
작업중=B, number=2, total=3
작업중=B, number=3, total=6
작업명=B, 걸린시간=3.000927209854126
총합=9, 총시간=3.000927209854126

A 작업과 B 작업을 교대로 호출한다. (제어권이 await에 의해 계속 바뀐다는 것을 알 수 있다.) 그리고 시간도 5초 걸리던 것이 3초만 걸리게 되므로 A, B 작업이 완전히 비동기적으로 동작했다는 것을 알 수 있다.

비슷한 예제

import asyncio
import time

# Sync 함수
def execute_calc_sync(name, n):
    for i in range(1, n+1):
        print(f"{name} -> {i} of {n} is calculating...")
        time.sleep(1)
        
    print(f"{name} is done!")

def process_sync():
    start = time.time()
    
    execute_calc_sync('one', 3)
    execute_calc_sync('two', 2)
    execute_calc_sync('three', 1)

    end = time.time()
    
    print(f"total seconds : {end - start}")

# Async 함수
async def execute_calc_async(name, n):
    for i in range(1, n+1):
        print(f"{name} -> {i} of {n} is calculating...")
        await asyncio.sleep(1)
        
    print(f"{name} is done!")

async def process_async():
    start = time.time()
    
    await asyncio.gather(
        execute_calc_async('one', 1),
        execute_calc_async('two', 2),
        execute_calc_async('three', 3)
    )
    
    end = time.time()
    print(f"total seconds : {end - start}")

if __name__ == "__main__":
    # Sync 실행
    # process_sync()
    
    # Async 실행
    # 파이썬 3.7 이상
    asyncio.run(process_async())

one -> 1 of 1 is calculating...
two -> 1 of 2 is calculating...
three -> 1 of 3 is calculating...
one is done!
two -> 2 of 2 is calculating...
three -> 2 of 3 is calculating...
two is done!
three -> 3 of 3 is calculating...
three is done!
total seconds : 3.0082101821899414

Sync함수로 실행하면 6초가 걸린다. 코드에서 ASync 함수부분에 집중하자. main에서 asyncio.run형태로 async함수를 호출한다. 그리고 여러개의 비동기 함수를 묶어서 await으로 호출할 수 있는 await asyncio,gather를 사용했다.

 

참고할 만한 문서

071 비동기 방식으로 프로그래밍하려면? ― asyncio

파이썬 코딩 도장: 47.10 asyncio 사용하기