Giới thiệu về nhiệm vụ và vòng lặp sự kiện

5.1 Vòng lặp sự kiện (Event Loop)

Bây giờ chúng ta sẽ nhanh chóng nói đến phần thứ hai của bất đồng bộ mà vẫn luôn xuất hiện từ mọi phía: vòng lặp sự kiện (Event Loop), nhiệm vụ (Task) và Future.

Hãy tưởng tượng Event Loop như một nhạc trưởng của dàn nhạc, Task như các nhạc công, và Future như những bản nhạc mà các nhạc công phải chơi. Nhạc trưởng (Event Loop) điều phối công việc của các nhạc công (Task), những người thực hiện âm nhạc (các hoạt động bất đồng bộ), đọc bản nhạc (Future).

Vòng lặp sự kiện (Event Loop) là nền tảng của lập trình bất đồng bộ trong Python. Nó chịu trách nhiệm thực thi các nhiệm vụ bất đồng bộ, quản lý các sự kiện và xử lý đầu vào/đầu ra. Vòng lặp sự kiện liên tục kiểm tra sự hiện diện của các sự kiện hoặc nhiệm vụ mới và khởi động chúng khi sẵn sàng.

Chức năng chính

• run_forever(): Khởi động vòng lặp sự kiện và tiếp tục chạy cho đến khi gọi stop().
• run_until_complete(future): Khởi động vòng lặp sự kiện và kết thúc nó sau khi hoàn thành đối tượng tương lai hoặc coroutine đã chỉ định.
• stop(): Dừng vòng lặp sự kiện.
• create_task(coroutine): Lên kế hoạch thực hiện coroutine như một nhiệm vụ.

Ví dụ sử dụng:

import asyncio

async def hello():
    print("Hello, world!")
    await asyncio.sleep(1)
    print("Hello again!")
            
loop = asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

Trong ví dụ này, trước tiên chúng ta sử dụng phương thức get_event_loop() để lấy đối tượng EventLoop hiện tại của thư viện asyncio.

Sau đó thêm coroutine hello vào EventLoop này và yêu cầu nó thực hiện bằng phương thức run_until_complete().

Trong bước cuối cùng, chúng ta đóng EventLoop bằng phương thức close().

Khi chạy mã này, bạn sẽ thấy rằng đầu tiên in ra "Hello, world!", sau đó chương trình đợi 1 giây và sau đó in ra "Hello again!". Điều này minh họa cách Event Loop quản lý thực thi hàm bất đồng bộ.

Sẽ xem xét chi tiết các hành động này trong bài giảng tiếp theo.

5.2 Tasks

Nhiệm vụ (Tasks) là lớp bọc cho coroutine, cho phép quản lý thực thi và theo dõi trạng thái của chúng. Nhiệm vụ cho phép chạy coroutine song song, quản lý chúng thông qua vòng lặp sự kiện.

Tạo và quản lý nhiệm vụ

• asyncio.create_task(coroutine): Tạo nhiệm vụ để thực hiện coroutine.
• Task.result(): Trả về kết quả của nhiệm vụ đã hoàn thành hoặc gây ra ngoại lệ nếu nhiệm vụ kết thúc có lỗi.
• Task.cancel(): Hủy việc thực hiện nhiệm vụ.

Ví dụ sử dụng:

import asyncio

async def say_hello():
    await asyncio.sleep(1)
    print("Hello")
            
async def main():
    task = asyncio.create_task(say_hello())
    await task
            
asyncio.run(main())

Trong ví dụ này, chúng ta bọc coroutine say_hello() bằng đối tượng Task. Nó cũng là đối tượng bất đồng bộ, vì vậy để lấy kết quả của nó, cần áp dụng toán tử await.

Khi thực thi mã này, chương trình sẽ đợi 1 giây rồi in ra "Hello". Điều này cho thấy cách Task quản lý thực hiện coroutine và cách chúng ta có thể chờ đợi nó hoàn thành bằng await.

Chi tiết hơn về làm việc với nhiệm vụ Task sẽ được thảo luận trong bài giảng tiếp theo.

5.3 Futures

Đối tượng Future đại diện cho kết quả của một hoạt động bất đồng bộ sẽ có sẵn trong tương lai. Chúng cho phép quản lý trạng thái hoạt động bất đồng bộ, thiết lập kết quả hoặc ngoại lệ.

Phương thức chính:

• set_result(result): Thiết lập kết quả cho đối tượng Future.
• set_exception(exception): Thiết lập ngoại lệ cho đối tượng Future.
• result(): Trả về kết quả của đối tượng Future hoặc gây ra ngoại lệ nếu hoạt động kết thúc có lỗi.
• exception(): Trả về ngoại lệ nếu nó đã được thiết lập.

Ví dụ sử dụng:

import asyncio

async def set_future(fut, value):
    await asyncio.sleep(1)
    fut.set_result(value)
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    await set_future(fut, 'Hello, future!')
    print(fut.result())
            
asyncio.run(main())

Trong ví dụ này, chúng ta tạo Future, thiết lập giá trị của nó sau một giây, và sau đó in ra kết quả. Bạn sẽ thấy rằng chương trình đợi một giây trước khi in 'Hello, future!'. Điều này minh họa cách Future đại diện cho kết quả sẽ có sẵn trong tương lai.

Khác với đối tượng Task, đối tượng Future được gắn với một Event Loop cụ thể, và hàm bất đồng bộ thực hiện có thể ghi kết quả của mình vào đó. Tuy nhiên, thường thì điều này hoạt động khác một chút.

Phần lớn các đối tượng Future được sử dụng cùng với nhiệm vụ Task, cung cấp quản lý ở mức cao hơn cho các hoạt động bất đồng bộ.

Bây giờ sau khi bạn đã làm quen với Event Loop, Task và Future, chúng ta sẽ xem xét chúng chi tiết hơn.