Hướng dẫn why async await is used in python? - tại sao async đang chờ được sử dụng trong python?

Async IO phù hợp ở đâu?

Đồng thời và song song là những chủ đề mở rộng không dễ dàng lội vào. Mặc dù bài viết này tập trung vào Async IO và việc triển khai của nó trong Python, nhưng nó đáng để mất một phút để so sánh IO ASYNC với các đối tác của mình để có bối cảnh về cách Async IO phù hợp với câu đố lớn hơn, đôi khi chóng mặt.

Sự song song bao gồm thực hiện nhiều hoạt động cùng một lúc. Đa xử lý là một phương tiện để thực hiện song song và nó đòi hỏi phải truyền bá các nhiệm vụ trên máy tính các đơn vị xử lý trung tâm (CPU hoặc lõi). Đa xử lý là rất phù hợp cho các nhiệm vụ liên kết CPU: các vòng lặp

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Đồng thời là một thuật ngữ rộng hơn một chút so với song song. Nó gợi ý rằng nhiều nhiệm vụ có khả năng chạy một cách chồng chéo. (Có một câu nói rằng đồng thời không bao hàm sự song song.) is a slightly broader term than parallelism. It suggests that multiple tasks have the ability to run in an overlapping manner. (There’s a saying that concurrency does not imply parallelism.)

Chủ đề là một mô hình thực thi đồng thời, theo đó nhiều luồng thay phiên nhau thực hiện các tác vụ. Một quá trình có thể chứa nhiều luồng. Python có một mối quan hệ phức tạp với luồng nhờ vào Gil của nó, nhưng điều đó vượt quá phạm vi của bài viết này. is a concurrent execution model whereby multiple threads take turns executing tasks. One process can contain multiple threads. Python has a complicated relationship with threading thanks to its GIL, but that’s beyond the scope of this article.

Điều quan trọng để biết về luồng là nó tốt hơn cho các nhiệm vụ ràng buộc IO. Mặc dù một nhiệm vụ liên kết CPU được đặc trưng bởi các lõi máy tính liên tục làm việc chăm chỉ từ đầu đến cuối, một công việc ràng buộc IO bị chi phối bởi rất nhiều sự chờ đợi về đầu vào/đầu ra để hoàn thành.

Để tóm tắt lại những điều trên, đồng thời bao gồm cả đa xử lý (lý tưởng cho các tác vụ gắn CPU) và luồng (phù hợp cho các tác vụ gắn IO). Đa xử lý là một hình thức song song, với sự song song là một loại (tập hợp con) cụ thể của đồng thời. Thư viện tiêu chuẩn Python đã cung cấp hỗ trợ lâu dài cho cả hai gói này thông qua các gói

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

$ python3 countsync.py
One
Two
One
Two
One
Two
countsync.py executed in 3.01 seconds.

$ python3 countsync.py
One
Two
One
Two
One
Two
countsync.py executed in 3.01 seconds.

Bây giờ, thời gian để đưa một thành viên mới vào hỗn hợp. Trong vài năm qua, một thiết kế riêng biệt đã được tích hợp toàn diện hơn vào CPython: IO không đồng bộ, được bật thông qua gói thư viện tiêu chuẩn ____ ____34 và từ khóa ngôn ngữ

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Gói

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Trên thực tế, Async IO là một thiết kế đơn, đơn, nó sử dụng đa nhiệm hợp tác, một thuật ngữ mà bạn sẽ đưa ra vào cuối hướng dẫn này. Nói cách khác, người ta đã nói rằng Async IO mang lại cảm giác đồng thời mặc dù sử dụng một luồng duy nhất trong một quy trình. Coroutines (một tính năng trung tâm của Async IO) có thể được lên lịch đồng thời, nhưng chúng không đồng thời.cooperative multitasking, a term that you’ll flesh out by the end of this tutorial. It has been said in other words that async IO gives a feeling of concurrency despite using a single thread in a single process. Coroutines (a central feature of async IO) can be scheduled concurrently, but they are not inherently concurrent.

Để nhắc lại, Async IO là một phong cách lập trình đồng thời, nhưng nó không phải là song song. Nó phù hợp chặt chẽ hơn với việc xâu chuỗi so với đa xử lý nhưng rất khác biệt với cả hai điều này và là một thành viên độc lập trong túi thủ thuật đồng thời.

Điều đó để lại một thuật ngữ nữa. Nó có ý nghĩa gì đối với một cái gì đó không đồng bộ? Đây là một định nghĩa nghiêm ngặt, nhưng với mục đích của chúng tôi ở đây, tôi có thể nghĩ về hai thuộc tính:asynchronous? This isn’t a rigorous definition, but for our purposes here, I can think of two properties:

• Các thói quen không đồng bộ có thể tạm dừng trong khi chờ đợi kết quả cuối cùng của họ và để các thói quen khác chạy trong lúc này.
• Mã không đồng bộ, thông qua cơ chế ở trên, tạo điều kiện thực hiện đồng thời. Nói cách khác, mã không đồng bộ mang lại cái nhìn và cảm giác đồng thời.

Ở đây, một sơ đồ để đặt tất cả lại với nhau. Các thuật ngữ màu trắng đại diện cho các khái niệm và các thuật ngữ xanh biểu thị các cách mà chúng được thực hiện hoặc thực hiện:

Tôi sẽ dừng lại ở đó về sự so sánh giữa các mô hình lập trình đồng thời. Hướng dẫn này tập trung vào thành phần phụ là async io, cách sử dụng nó và các API đã xuất hiện xung quanh nó. Để khám phá kỹ lưỡng về luồng so với đa xử lý so với Async IO, tạm dừng ở đây và kiểm tra tổng quan về Jim Anderson về sự đồng thời trong Python. Jim là người hài hước hơn tôi và đã ngồi trong nhiều cuộc họp hơn tôi, để khởi động.

Async IO giải thích

Async IO lúc đầu có vẻ phản trực giác và nghịch lý. Làm thế nào để một cái gì đó tạo điều kiện cho mã đồng thời sử dụng một luồng duy nhất và một lõi CPU duy nhất? Tôi không bao giờ giỏi trong việc gợi lên các ví dụ, vì vậy tôi đã muốn diễn giải một trong những bài nói chuyện của Miguel Grinberg, 2017, giải thích mọi thứ khá đẹp mắt:

Chess Master Judit Polgár tổ chức một triển lãm cờ vua, trong đó cô đóng vai nhiều người chơi nghiệp dư. Cô có hai cách tiến hành triển lãm: đồng bộ và không đồng bộ.

Assumptions:

• 24 đối thủ
• Judit làm cho mỗi cờ vua di chuyển trong 5 giây
• Đối thủ mỗi người mất 55 giây để thực hiện một động thái
• Trò chơi trung bình 30 cặp đôi (tổng số 60 động tác)

Phiên bản đồng bộ: Judit chơi một trò chơi tại một thời điểm, không bao giờ hai lần cùng một lúc, cho đến khi trò chơi hoàn tất. Mỗi trò chơi mất (55 + 5) * 30 == 1800 giây hoặc 30 phút. Toàn bộ triển lãm mất 24 * 30 == 720 phút, hoặc 12 giờ.: Judit plays one game at a time, never two at the same time, until the game is complete. Each game takes (55 + 5) * 30 == 1800 seconds, or 30 minutes. The entire exhibition takes 24 * 30 == 720 minutes, or 12 hours.

Phiên bản không đồng bộ: Judit di chuyển từ bảng này sang bảng khác, thực hiện một di chuyển ở mỗi bảng. Cô rời khỏi bàn và để đối thủ thực hiện bước đi tiếp theo của họ trong thời gian chờ đợi. Một động tác trên tất cả 24 trò chơi cần Judit 24 * 5 == 120 giây hoặc 2 phút. Toàn bộ triển lãm hiện được cắt giảm xuống còn 120 * 30 == 3600 giây, hoặc chỉ 1 giờ. (Nguồn): Judit moves from table to table, making one move at each table. She leaves the table and lets the opponent make their next move during the wait time. One move on all 24 games takes Judit 24 * 5 == 120 seconds, or 2 minutes. The entire exhibition is now cut down to 120 * 30 == 3600 seconds, or just 1 hour. (Source)

Chỉ có một Judit Polgár, người chỉ có hai tay và chỉ tự mình di chuyển một lần. Nhưng chơi không đồng bộ cắt giảm thời gian triển lãm giảm từ 12 giờ xuống một. Vì vậy, đa nhiệm hợp tác là một cách thú vị để nói rằng một vòng lặp sự kiện của chương trình (nhiều hơn về sau) giao tiếp với nhiều nhiệm vụ để cho mỗi lần thay phiên nhau chạy vào thời điểm tối ưu.

Async IO mất nhiều thời gian chờ đợi trong đó các chức năng sẽ bị chặn và cho phép các chức năng khác chạy trong thời gian ngừng hoạt động đó. (Một chức năng chặn hiệu quả cấm người khác chạy từ thời điểm bắt đầu cho đến khi nó trở lại.)

Async io không dễ dàng

Tôi đã nghe nó nói, sử dụng IO Async khi bạn có thể; Sử dụng luồng khi bạn phải. Sự thật là việc xây dựng mã đa luồng bền có thể khó và dễ bị lỗi. Async IO tránh được một số tốc độ tiềm năng mà bạn có thể gặp phải với một thiết kế ren.

Nhưng điều đó không thể nói rằng IO Async trong Python rất dễ dàng. Được cảnh báo: Khi bạn mạo hiểm thấp hơn một chút dưới mức bề mặt, chương trình Async cũng có thể khó khăn! Mô hình Async của Python, được xây dựng xung quanh các khái niệm như gọi lại, sự kiện, vận chuyển, giao thức và tương lai, chỉ có thuật ngữ có thể đáng sợ. Thực tế là API của nó đã thay đổi liên tục làm cho nó không dễ dàng hơn.

May mắn thay,

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

________ 32/________ 33 Cú pháp và coroutines bản địa

Trọng tâm của Async IO là coroutines. Một coroutine là một phiên bản chuyên dụng của hàm tạo Python. Hãy bắt đầu với một định nghĩa cơ bản và sau đó xây dựng nó khi bạn tiến bộ ở đây: Coroutine là một chức năng có thể đình chỉ thực thi trước khi đạt

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

Sau đó, bạn sẽ đi sâu hơn rất nhiều về cách chính xác trình tạo truyền thống được tái sử dụng thành một coroutine. Hiện tại, cách dễ nhất để chọn cách thức hoạt động của Coroutines là bắt đầu tạo ra một số.

Hãy để cách tiếp cận nhập vai và viết một số mã IO không đồng bộ. Chương trình ngắn này là

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Khi bạn thực hiện tệp này, hãy lưu ý những gì trông khác so với nếu bạn xác định các chức năng chỉ với

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

$ python3 countasync.py
One
One
One
Two
Two
Two
countasync.py executed in 1.01 seconds.

Thứ tự của đầu ra này là trái tim của Async IO. Nói chuyện với từng cuộc gọi đến

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

Tương phản điều này với phiên bản đồng bộ:

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Khi được thực hiện, có một thay đổi nhẹ nhưng quan trọng theo thứ tự và thời gian thực hiện:

$ python3 countsync.py
One
Two
One
Two
One
Two
countsync.py executed in 3.01 seconds.

Mặc dù sử dụng

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

Như bạn sẽ thấy trong phần tiếp theo, lợi ích của việc chờ đợi một cái gì đó, bao gồm

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

Các quy tắc của async io

Tại thời điểm này, một định nghĩa chính thức hơn của

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

• Cú pháp

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  2 giới thiệu một coroutine gốc hoặc một máy phát không đồng bộ. Các biểu thức

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  3 và

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  4 cũng hợp lệ và bạn sẽ thấy chúng sau này.native coroutine or an asynchronous generator. The expressions

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  3 and

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  4 are also valid, and you’ll see them later on.

• Từ khóa

  #!/usr/bin/env python3
  # countsync.py
  
  import time
  
  def count():
      print("One")
      time.sleep(1)
      print("Two")
  
  def main():
      for _ in range(3):
          count()
  
  if __name__ == "__main__":
      s = time.perf_counter()
      main()
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  3 chuyển kiểm soát chức năng trở lại vòng lặp sự kiện. . Được trả lại. Trong khi chờ đợi, hãy để một cái gì đó khác chạy.

Trong mã, điểm đạn thứ hai đó trông gần như thế này:

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

Ngoài ra, còn có một bộ quy tắc nghiêm ngặt xung quanh khi nào và làm thế nào bạn có thể và không thể sử dụng ____ 32/________ 33. Chúng có thể hữu ích cho dù bạn vẫn đang chọn cú pháp hay đã tiếp xúc với việc sử dụng ________ 32/________ 33:

• Một chức năng mà bạn giới thiệu với

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  2 là một coroutine. Nó có thể sử dụng

  #!/usr/bin/env python3
  # countsync.py
  
  import time
  
  def count():
      print("One")
      time.sleep(1)
      print("Two")
  
  def main():
      for _ in range(3):
          count()
  
  if __name__ == "__main__":
      s = time.perf_counter()
      main()
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  3,

  async def g():
      # Pause here and come back to g() when f() is ready
      r = await f()
      return r
  

  5 hoặc

  #!/usr/bin/env python3
  # rand.py
  
  import asyncio
  import random
  
  # ANSI colors
  c = (
      "\033[0m",   # End of color
      "\033[36m",  # Cyan
      "\033[91m",  # Red
      "\033[35m",  # Magenta
  )
  
  async def makerandom(idx: int, threshold: int = 6) -> int:
      print(c[idx + 1] + f"Initiated makerandom({idx}).")
      i = random.randint(0, 10)
      while i <= threshold:
          print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
          await asyncio.sleep(idx + 1)
          i = random.randint(0, 10)
      print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
      return i
  
  async def main():
      res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
      return res
  
  if __name__ == "__main__":
      random.seed(444)
      r1, r2, r3 = asyncio.run(main())
      print()
      print(f"r1: {r1}, r2: {r2}, r3: {r3}")
  

  8, nhưng tất cả những thứ này là tùy chọn. Tuyên bố

  #!/usr/bin/env python3
  # rand.py
  
  import asyncio
  import random
  
  # ANSI colors
  c = (
      "\033[0m",   # End of color
      "\033[36m",  # Cyan
      "\033[91m",  # Red
      "\033[35m",  # Magenta
  )
  
  async def makerandom(idx: int, threshold: int = 6) -> int:
      print(c[idx + 1] + f"Initiated makerandom({idx}).")
      i = random.randint(0, 10)
      while i <= threshold:
          print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
          await asyncio.sleep(idx + 1)
          i = random.randint(0, 10)
      print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
      return i
  
  async def main():
      res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
      return res
  
  if __name__ == "__main__":
      random.seed(444)
      r1, r2, r3 = asyncio.run(main())
      print()
      print(f"r1: {r1}, r2: {r2}, r3: {r3}")
  

  9 là hợp lệ:

  • Sử dụng

    #!/usr/bin/env python3
    # countsync.py
    
    import time
    
    def count():
        print("One")
        time.sleep(1)
        print("Two")
    
    def main():
        for _ in range(3):
            count()
    
    if __name__ == "__main__":
        s = time.perf_counter()
        main()
        elapsed = time.perf_counter() - s
        print(f"{__file__} executed in {elapsed:0.2f} seconds.")
    

    3 và/hoặc

    async def g():
        # Pause here and come back to g() when f() is ready
        r = await f()
        return r
    

    5 tạo ra chức năng coroutine. Để gọi chức năng coroutine, bạn phải

    #!/usr/bin/env python3
    # countsync.py
    
    import time
    
    def count():
        print("One")
        time.sleep(1)
        print("Two")
    
    def main():
        for _ in range(3):
            count()
    
    if __name__ == "__main__":
        s = time.perf_counter()
        main()
        elapsed = time.perf_counter() - s
        print(f"{__file__} executed in {elapsed:0.2f} seconds.")
    

    3 nó để có kết quả.

  • Nó ít phổ biến hơn (và chỉ gần đây hợp pháp trong Python) để sử dụng

    #!/usr/bin/env python3
    # rand.py
    
    import asyncio
    import random
    
    # ANSI colors
    c = (
        "\033[0m",   # End of color
        "\033[36m",  # Cyan
        "\033[91m",  # Red
        "\033[35m",  # Magenta
    )
    
    async def makerandom(idx: int, threshold: int = 6) -> int:
        print(c[idx + 1] + f"Initiated makerandom({idx}).")
        i = random.randint(0, 10)
        while i <= threshold:
            print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
            await asyncio.sleep(idx + 1)
            i = random.randint(0, 10)
        print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
        return i
    
    async def main():
        res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
        return res
    
    if __name__ == "__main__":
        random.seed(444)
        r1, r2, r3 = asyncio.run(main())
        print()
        print(f"r1: {r1}, r2: {r2}, r3: {r3}")
    

    8 trong một khối

    import asyncio
    
    @asyncio.coroutine
    def py34_coro():
        """Generator-based coroutine, older syntax"""
        yield from stuff()
    
    async def py35_coro():
        """Native coroutine, modern syntax"""
        await stuff()
    

    2. Điều này tạo ra một máy phát không đồng bộ, mà bạn lặp lại với

    import asyncio
    
    @asyncio.coroutine
    def py34_coro():
        """Generator-based coroutine, older syntax"""
        yield from stuff()
    
    async def py35_coro():
        """Native coroutine, modern syntax"""
        await stuff()
    

    4. Hãy quên đi các trình tạo async trong thời gian này và tập trung vào việc giảm cú pháp cho các chức năng coroutine, sử dụng

    #!/usr/bin/env python3
    # countsync.py
    
    import time
    
    def count():
        print("One")
        time.sleep(1)
        print("Two")
    
    def main():
        for _ in range(3):
            count()
    
    if __name__ == "__main__":
        s = time.perf_counter()
        main()
        elapsed = time.perf_counter() - s
        print(f"{__file__} executed in {elapsed:0.2f} seconds.")
    

    3 và/hoặc

    async def g():
        # Pause here and come back to g() when f() is ready
        r = await f()
        return r
    

    5.

  • Bất cứ điều gì được xác định với

    import asyncio
    
    @asyncio.coroutine
    def py34_coro():
        """Generator-based coroutine, older syntax"""
        yield from stuff()
    
    async def py35_coro():
        """Native coroutine, modern syntax"""
        await stuff()
    

    2 đều không được sử dụng

    #!/usr/bin/env python3
    # chained.py
    
    import asyncio
    import random
    import time
    
    async def part1(n: int) -> str:
        i = random.randint(0, 10)
        print(f"part1({n}) sleeping for {i} seconds.")
        await asyncio.sleep(i)
        result = f"result{n}-1"
        print(f"Returning part1({n}) == {result}.")
        return result
    
    async def part2(n: int, arg: str) -> str:
        i = random.randint(0, 10)
        print(f"part2{n, arg} sleeping for {i} seconds.")
        await asyncio.sleep(i)
        result = f"result{n}-2 derived from {arg}"
        print(f"Returning part2{n, arg} == {result}.")
        return result
    
    async def chain(n: int) -> None:
        start = time.perf_counter()
        p1 = await part1(n)
        p2 = await part2(n, p1)
        end = time.perf_counter() - start
        print(f"-->Chained result{n} => {p2} (took {end:0.2f} seconds).")
    
    async def main(*args):
        await asyncio.gather(*(chain(n) for n in args))
    
    if __name__ == "__main__":
        import sys
        random.seed(444)
        args = [1, 2, 3] if len(sys.argv) == 1 else map(int, sys.argv[1:])
        start = time.perf_counter()
        asyncio.run(main(*args))
        end = time.perf_counter() - start
        print(f"Program finished in {end:0.2f} seconds.")
    

    9, sẽ tăng

    #!/usr/bin/env python3
    # countasync.py
    
    import asyncio
    
    async def count():
        print("One")
        await asyncio.sleep(1)
        print("Two")
    
    async def main():
        await asyncio.gather(count(), count(), count())
    
    if __name__ == "__main__":
        import time
        s = time.perf_counter()
        asyncio.run(main())
        elapsed = time.perf_counter() - s
        print(f"{__file__} executed in {elapsed:0.2f} seconds.")
    

    00.

• Giống như nó là một

  #!/usr/bin/env python3
  # countasync.py
  
  import asyncio
  
  async def count():
      print("One")
      await asyncio.sleep(1)
      print("Two")
  
  async def main():
      await asyncio.gather(count(), count(), count())
  
  if __name__ == "__main__":
      import time
      s = time.perf_counter()
      asyncio.run(main())
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  00 để sử dụng

  #!/usr/bin/env python3
  # rand.py
  
  import asyncio
  import random
  
  # ANSI colors
  c = (
      "\033[0m",   # End of color
      "\033[36m",  # Cyan
      "\033[91m",  # Red
      "\033[35m",  # Magenta
  )
  
  async def makerandom(idx: int, threshold: int = 6) -> int:
      print(c[idx + 1] + f"Initiated makerandom({idx}).")
      i = random.randint(0, 10)
      while i <= threshold:
          print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
          await asyncio.sleep(idx + 1)
          i = random.randint(0, 10)
      print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
      return i
  
  async def main():
      res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
      return res
  
  if __name__ == "__main__":
      random.seed(444)
      r1, r2, r3 = asyncio.run(main())
      print()
      print(f"r1: {r1}, r2: {r2}, r3: {r3}")
  

  8 bên ngoài hàm

  async def g():
      # Pause here and come back to g() when f() is ready
      r = await f()
      return r
  

  7, đó là một

  #!/usr/bin/env python3
  # countasync.py
  
  import asyncio
  
  async def count():
      print("One")
      await asyncio.sleep(1)
      print("Two")
  
  async def main():
      await asyncio.gather(count(), count(), count())
  
  if __name__ == "__main__":
      import time
      s = time.perf_counter()
      asyncio.run(main())
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  00 để sử dụng

  #!/usr/bin/env python3
  # countsync.py
  
  import time
  
  def count():
      print("One")
      time.sleep(1)
      print("Two")
  
  def main():
      for _ in range(3):
          count()
  
  if __name__ == "__main__":
      s = time.perf_counter()
      main()
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  3 bên ngoài

  import asyncio
  
  @asyncio.coroutine
  def py34_coro():
      """Generator-based coroutine, older syntax"""
      yield from stuff()
  
  async def py35_coro():
      """Native coroutine, modern syntax"""
      await stuff()
  

  2 Coroutine. Bạn chỉ có thể sử dụng

  #!/usr/bin/env python3
  # countsync.py
  
  import time
  
  def count():
      print("One")
      time.sleep(1)
      print("Two")
  
  def main():
      for _ in range(3):
          count()
  
  if __name__ == "__main__":
      s = time.perf_counter()
      main()
      elapsed = time.perf_counter() - s
      print(f"{__file__} executed in {elapsed:0.2f} seconds.")
  

  3 trong cơ thể của coroutines.

Dưới đây là một số ví dụ ngắn gọn nhằm tóm tắt các quy tắc trên:

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

Cuối cùng, khi bạn sử dụng

import asyncio

@asyncio.coroutine
def py34_coro():
    """Generator-based coroutine, older syntax"""
    yield from stuff()

async def py35_coro():
    """Native coroutine, modern syntax"""
    await stuff()

#!/usr/bin/env python3
# rand.py

import asyncio
import random

# ANSI colors
c = (
    "\033[0m",   # End of color
    "\033[36m",  # Cyan
    "\033[91m",  # Red
    "\033[35m",  # Magenta
)

async def makerandom(idx: int, threshold: int = 6) -> int:
    print(c[idx + 1] + f"Initiated makerandom({idx}).")
    i = random.randint(0, 10)
    while i <= threshold:
        print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
        await asyncio.sleep(idx + 1)
        i = random.randint(0, 10)
    print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
    return i

async def main():
    res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
    return res

if __name__ == "__main__":
    random.seed(444)
    r1, r2, r3 = asyncio.run(main())
    print()
    print(f"r1: {r1}, r2: {r2}, r3: {r3}")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Điều đó đưa chúng ta đến một sự khác biệt kỹ thuật nữa mà bạn có thể thấy Pop Up: cách đánh dấu một chức năng như một coroutine là trang trí chức năng

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Hai coroutines này về cơ bản là tương đương (cả hai đều có thể chờ đợi), nhưng đầu tiên là dựa trên máy phát điện, trong khi thứ hai là một coroutine tự nhiên:generator-based, while the second is a native coroutine:

import asyncio

@asyncio.coroutine
def py34_coro():
    """Generator-based coroutine, older syntax"""
    yield from stuff()

async def py35_coro():
    """Native coroutine, modern syntax"""
    await stuff()

Nếu bạn tự viết bất kỳ mã nào, hãy thích các coroutines bản địa vì mục đích rõ ràng hơn là ẩn. Coroutines dựa trên máy phát điện sẽ bị loại bỏ trong Python 3.10.

Đối với nửa sau của hướng dẫn này, chúng tôi sẽ chạm vào các coroutines dựa trên máy phát điện để giải thích. Lý do mà ________ 32/________ 33 được giới thiệu là để biến coroutines thành một đặc điểm độc lập của python có thể dễ dàng phân biệt với hàm máy phát bình thường, do đó làm giảm sự mơ hồ.

Don Tiết bị sa lầy vào các coroutines dựa trên máy phát điện, đã bị cố tình lỗi thời bởi ____ 32/________ 33. Họ có bộ quy tắc nhỏ của riêng mình (ví dụ,

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Không cần phải quảng cáo thêm, hãy để Lừa nhận thêm một vài ví dụ liên quan.

Dưới đây là một ví dụ về cách async IO cắt giảm thời gian chờ: đưa ra một coroutine

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# rand.py

import asyncio
import random

# ANSI colors
c = (
    "\033[0m",   # End of color
    "\033[36m",  # Cyan
    "\033[91m",  # Red
    "\033[35m",  # Magenta
)

async def makerandom(idx: int, threshold: int = 6) -> int:
    print(c[idx + 1] + f"Initiated makerandom({idx}).")
    i = random.randint(0, 10)
    while i <= threshold:
        print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")
        await asyncio.sleep(idx + 1)
        i = random.randint(0, 10)
    print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
    return i

async def main():
    res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
    return res

if __name__ == "__main__":
    random.seed(444)
    r1, r2, r3 = asyncio.run(main())
    print()
    print(f"r1: {r1}, r2: {r2}, r3: {r3}")

Đầu ra màu nói nhiều hơn tôi có thể và mang lại cho bạn ý nghĩa về cách thực hiện tập lệnh này:

Chương trình này sử dụng một coroutine chính,

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Trong ví dụ thu nhỏ này, nhóm là

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Mặc dù việc tạo ra các số nguyên ngẫu nhiên, một số lượng lớn hơn (có thể không phải là lựa chọn lớn nhất với tư cách là ứng cử viên cho

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

Chuỗi coroutines

Một tính năng chính của coroutines là chúng có thể được xích lại với nhau. .

#!/usr/bin/env python3
# chained.py

import asyncio
import random
import time

async def part1(n: int) -> str:
    i = random.randint(0, 10)
    print(f"part1({n}) sleeping for {i} seconds.")
    await asyncio.sleep(i)
    result = f"result{n}-1"
    print(f"Returning part1({n}) == {result}.")
    return result

async def part2(n: int, arg: str) -> str:
    i = random.randint(0, 10)
    print(f"part2{n, arg} sleeping for {i} seconds.")
    await asyncio.sleep(i)
    result = f"result{n}-2 derived from {arg}"
    print(f"Returning part2{n, arg} == {result}.")
    return result

async def chain(n: int) -> None:
    start = time.perf_counter()
    p1 = await part1(n)
    p2 = await part2(n, p1)
    end = time.perf_counter() - start
    print(f"-->Chained result{n} => {p2} (took {end:0.2f} seconds).")

async def main(*args):
    await asyncio.gather(*(chain(n) for n in args))

if __name__ == "__main__":
    import sys
    random.seed(444)
    args = [1, 2, 3] if len(sys.argv) == 1 else map(int, sys.argv[1:])
    start = time.perf_counter()
    asyncio.run(main(*args))
    end = time.perf_counter() - start
    print(f"Program finished in {end:0.2f} seconds.")

Hãy chú ý cẩn thận đến đầu ra, trong đó

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Trong thiết lập này, thời gian chạy của

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Sử dụng hàng đợi

Gói

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Có một cấu trúc thay thế cũng có thể hoạt động với Async IO: một số nhà sản xuất, không liên quan đến nhau, thêm các mặt hàng vào hàng đợi. Mỗi nhà sản xuất có thể thêm nhiều mặt hàng vào hàng đợi vào thời gian so le, ngẫu nhiên, không báo trước. Một nhóm người tiêu dùng kéo các mặt hàng từ hàng đợi khi họ xuất hiện, tham lam và không chờ đợi bất kỳ tín hiệu nào khác.

Trong thiết kế này, không có chuỗi người tiêu dùng cá nhân nào cho nhà sản xuất. Người tiêu dùng không biết số lượng nhà sản xuất, hoặc thậm chí số lượng các mặt hàng tích lũy sẽ được thêm vào hàng đợi, trước.

Nó cần một nhà sản xuất riêng lẻ hoặc người tiêu dùng một lượng thời gian thay đổi để đặt và trích xuất các mặt hàng từ hàng đợi, tương ứng. Hàng đợi phục vụ như một thông lượng có thể giao tiếp với các nhà sản xuất và người tiêu dùng mà không cần nói chuyện trực tiếp với nhau.

Phiên bản đồng bộ của chương trình này sẽ trông khá ảm đạm: một nhóm các nhà sản xuất chặn thêm các mặt hàng vào hàng đợi, một nhà sản xuất tại một thời điểm. Chỉ sau khi tất cả các nhà sản xuất được thực hiện, hàng đợi mới có thể được xử lý, bởi một người tiêu dùng tại một thời điểm xử lý từng mặt hàng. Có rất nhiều độ trễ trong thiết kế này. Các mặt hàng có thể ngồi yên trong hàng đợi thay vì được chọn và xử lý ngay lập tức.

Một phiên bản không đồng bộ,

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

(Cảm ơn một số sự giúp đỡ từ người dùng StackOverflow vì đã giúp làm thẳng

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Đây là toàn bộ kịch bản:

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Một vài coroutines đầu tiên là các hàm trợ giúp trả về một chuỗi ngẫu nhiên, một bộ đếm hiệu suất thứ hai phân đoạn và một số nguyên ngẫu nhiên. Một nhà sản xuất đặt bất cứ nơi nào từ 1 đến 5 mặt hàng vào hàng đợi. Mỗi mục là một bộ giảm mạnh

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Khi một người tiêu dùng rút một mặt hàng ra, nó chỉ cần tính toán thời gian đã trôi qua mà mặt hàng ngồi trong hàng đợi bằng dấu thời gian mà vật phẩm được đưa vào.

Hãy nhớ rằng

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

Dưới đây là một thử nghiệm với hai nhà sản xuất và năm người tiêu dùng:

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Trong trường hợp này, các mục xử lý theo phân số của một giây. Một sự chậm trễ có thể là do hai lý do:

• Tiêu chuẩn, phần lớn không thể tránh khỏi
• Tình huống mà tất cả người tiêu dùng đang ngủ khi một mặt hàng xuất hiện trong hàng đợi

Liên quan đến lý do thứ hai, may mắn thay, việc mở rộng quy mô lên hàng trăm hoặc hàng ngàn người tiêu dùng là hoàn toàn bình thường. Bạn không nên có vấn đề với

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Cho đến nay, bạn đã bị ném ngay vào đám cháy và thấy ba ví dụ liên quan của

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")