Thoát chức năng async 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 thâm nhập vào. Mặc dù bài viết này tập trung vào async IO và việc triển khai nó trong Python, nhưng bạn nên dành một phút để so sánh async IO với các đối tác của nó để 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

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 tính song song và nó kéo theo các tác vụ trải rộng trên các đơn vị xử lý trung tâm của máy tính [CPU hoặc lõi]. Đa xử lý rất phù hợp với các tác vụ liên quan đến CPU. các vòng lặp

$ python3 countsync.py
One
Two
One
Two
One
Two
countsync.py executed in 3.01 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 tác vụ có khả năng chạy theo cách chồng chéo. [Có một câu nói rằng đồng thời không có nghĩa là song song. ]

Phân luồng 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 tiến trình có thể chứa nhiều luồng. Python có mối quan hệ phức tạp với luồng nhờ GIL của nó, nhưng điều đó nằm ngoài phạm vi của bài viết này

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

Tóm 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ụ liên kết với CPU] và phân luồng [phù hợp với các tác vụ liên kết với IO]. Đa xử lý là một dạng song song, với song song là một loại [tập hợp con] cụ thể của đồng thời. Thư viện chuẩn Python đã cung cấp hỗ trợ lâu dài cho cả hai thứ này thông qua các gói

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

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

Bây giờ là lúc đư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 kích hoạt thông qua 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
# 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 luồng, một quy trình. nó sử dụng đa nhiệm hợp tác, một thuật ngữ mà bạn sẽ hiểu rõ ở phần cuối của hướng dẫn này. Nói cách khác, người ta nói rằng IO không đồng bộ mang lại cảm giác đồng thời mặc dù sử dụng một luồng đơn lẻ trong một quy trình. Các coroutine [một tính năng trung tâm của IO không đồng bộ] có thể được lên lịch đồng thời, nhưng chúng vốn không đồng thời

Xin nhắc lại, async IO là một kiểu lập trình đồng thời, nhưng nó không phải là song song. Nó được liên kết chặt chẽ hơn với luồng hơn là đa xử lý nhưng rất khác biệt so 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

Vậy là còn một nhiệm kỳ nữa. Điều đó có nghĩa là gì đối với một cái gì đó không đồng bộ?

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

Đây là một sơ đồ để kết hợp tất cả lại với nhau. Các điều khoản màu trắng đại diện cho các khái niệm và các điều khoản màu xanh lá cây đại diện cho các cách mà chúng được triển khai hoặc thực hiện

Tôi sẽ dừng lại ở phần 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 con không đồng bộ 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ề phân luồng so với đa xử lý so với IO không đồng bộ, hãy tạm dừng tại đây và xem tổng quan về đồng thời trong Python của Jim Anderson. Jim hài hước hơn tôi rất nhiều và đã ngồi trong nhiều cuộc họp hơn tôi.

Giải thích IO không đồng bộ

Async IO thoạt nghe 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 và một lõi CPU?

Kiện tướng cờ vua Judit Polgár tổ chức một cuộc triển lãm cờ vua trong đó bà đấu với nhiều kỳ thủ nghiệp dư. Cô ấy có hai cách để tiến hành cuộc triển lãm. đồng bộ và không đồng bộ

giả định

• 24 đối thủ
• Judit thực hiện mỗi nước cờ trong 5 giây
• Mỗi đối thủ mất 55 giây để di chuyển
• Trò chơi có trung bình 30 nước đi đôi [tổng cộng 60 nước đi]

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ờ chơi hai trò chơi cùng một lúc, cho đến khi trò chơi kết thúc. 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ờ

Phiên bản không đồng bộ. Judit di chuyển từ bàn này sang bàn khác, thực hiện một động tác ở mỗi bàn. Cô ấy rời khỏi bàn và để đối thủ thực hiện nước đi tiếp theo trong thời gian chờ đợi. Một nước đi trong tất cả 24 ván sẽ mất 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]

Chỉ có một Judit Polgár, người chỉ có hai tay và chỉ tự mình thực hiện một động tác tại một thời điểm. Nhưng chơi không đồng bộ giảm thời gian triển lãm từ 12 giờ xuống còn một giờ. Vì vậy, đa nhiệm hợp tác là một cách thú vị để nói rằng vòng lặp sự kiện của chương trình [sẽ nói thêm về điều đó sau] giao tiếp với nhiều tác vụ để cho phép mỗi tác vụ lần lượt 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 những người khác chạy từ khi nó bắt đầu cho đến khi nó quay trở lại. ]

IO không đồng bộ không dễ dàng

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

Nhưng điều đó không có nghĩa là IO async trong Python rất dễ dàng. được cảnh báo. khi bạn mạo hiểm dưới mức bề mặt một chút, việc lập trình không đồng bộ cũng có thể khó khăn. Mô hình không đồng bộ của Python được xây dựng dựa trên 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ỉ thuật ngữ thôi cũng có thể khiến bạn sợ hãi. Thực tế là API của nó đã thay đổi liên tục khiến 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."]

Cú phá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."]

3/

#!/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."]

4 và các Coroutine bản địa

Một lời cảnh báo. Hãy cẩn thận với những gì bạn đọc trên Internet. API IO không đồng bộ của Python đã phát triển nhanh chóng từ Python 3. 4 đến Python 3. 7. Một số mẫu cũ không còn được sử dụng và một số thứ ban đầu không được phép hiện được cho phép thông qua các phần giới thiệu mới

Trọng tâm của async IO là các coroutine. Một coroutine là một phiên bản chuyên biệt 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. một coroutine là một chức năng có thể tạm dừng thực thi của nó trước khi đạt đến

#!/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."]

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

Hãy thực hiện 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à

#!/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."]

Khi bạn thực thi tệp này, hãy lưu ý xem có gì khác so với khi bạn định nghĩa các hàm chỉ vớ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
# 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."]

Thứ tự của đầu ra này là trung tâm của IO không đồng bộ. Nói chuyện với từng cuộc gọi tớ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
# 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."]

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 thực hiện, có một thay đổi nhỏ nhưng quan trọng về thứ tự và thời gian thực hiện

________số 8

Mặc dù việc 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."]

#!/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."]

#!/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."]

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

#!/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."]

Quy tắc của IO không đồng bộ

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

#!/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."]

#!/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

  #!/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."]
  

  64 giới thiệu một coroutine gốc hoặc một trình tạo không đồng bộ. Các biểu thức

  #!/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."]
  

  65 và

  #!/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."]
  

  66 cũng hợp lệ và bạn sẽ thấy chúng sau này

• 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."]
  

  4 chuyển điều khiển chức năng trở lại vòng lặp sự kiện. [Nó tạm dừng việc thực thi coroutine xung quanh. ] Nếu Python gặp một biểu thức

  #!/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."]
  

  68 trong phạm vi 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."]
  

  69, thì đây là cách

  #!/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."]
  

  4 báo cho vòng lặp sự kiện, “Tạm dừng thực thi 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."]
  

  69 cho đến khi bất cứ điều gì tôi đang chờ đợi—kết quả 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."]
  

  42—được trả về. Trong khi chờ đợi, hãy để thứ khác chạy. ”

Trong mã, gạch đầu dòng thứ hai trông giống như thế này

#!/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."]

Ngoài ra còn có một bộ quy tắc nghiêm ngặt về thời điểm và cách thức bạn có thể và không 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."]

#!/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."]

• Một chức năng mà bạn giới thiệu vớ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."]
  

  64 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."]
  

  4,

  #!/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."]
  

  57 hoặc

  #!/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."]
  

  30, nhưng tất cả đều là tùy chọn. Khai báo

  #!/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."]
  

  31 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."]
    

    4 và/hoặc

    #!/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."]
    

    57 để tạo một hàm coroutine. Để gọi một 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."]
    

    4 nó để có được kết quả của nó

  • Việc 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."]
    

    30 trong khố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."]
    

    64 ít phổ biến hơn [và chỉ hợp pháp gần đây trong Python]. Điều này tạo ra một trình tạo không đồng bộ mà bạn lặp lại vớ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."]
    

    66. Tạm thời quên đi các trình tạo async và tập trung vào việc tìm hiểu cú pháp cho các hàm 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."]
    

    4 và/hoặc

    #!/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."]
    

    57

  • Bất kỳ thứ gì được xác định bằ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."]
    

    64 đều không được 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."]
    

    701, điều này sẽ làm tă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."]
    

    702

• Giống như việc 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."]
  

  702 bên ngoài chức 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."]
  

  59 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."]
  

  702, thì đó là một

  #!/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."]
  

  702 để 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."]
  

  4 bên ngoài quy trình đăng ký

  #!/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."]
  

  64. 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."]
  

  4 trong phần thân của coroutines

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

#!/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."]

Cuối cùng, khi bạn 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."]

#!/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."]

Điều đó đưa chúng ta đến một điểm khác biệt kỹ thuật nữa mà bạn có thể thấy cửa sổ bật lên. một cách cũ hơn để đánh dấu một hàm dưới dạng coroutine là trang trí một hàm

#!/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."]

#!/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 coroutine này về cơ bản là tương đương nhau [cả hai đều có thể chờ được], nhưng cái thứ nhất dựa trên trình tạo, trong khi cái thứ hai là một coroutine gốc

#!/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."]

Nếu bạn đang tự viết bất kỳ mã nào, hãy ưu tiên các coroutine gốc vì mục đích rõ ràng hơn là ẩn. Các coroutine dựa trên trình tạo sẽ có trong Python 3. 10

Ở nửa sau của hướng dẫn này, chúng ta sẽ chỉ đề cập đến các coroutine dựa trên trình tạo để giải thích. Lý do mà

#!/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 sa lầy vào các chương trình coroutine dựa trên máy phát điện, vốn đã có từ ngày

#!/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."]

Không có gì khó chịu, chúng ta hãy lấy thêm một vài ví dụ liên quan

Đây là một ví dụ về cách IO không đồng bộ cắt giảm thời gian chờ đợi. cho một coroutine

#!/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."]

Đầu ra được tô màu nói lên nhiều điều hơn tôi có thể và cho bạn biết 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
# 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."]

Trong ví dụ thu nhỏ này, hồ bơi là

#!/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."]

Mặc dù "tạo số nguyên ngẫu nhiên" [được giới hạn bởi CPU hơn bất kỳ thứ gì] có thể không phải là lựa chọn tốt 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."]

#!/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."]

Xâu chuỗi Coroutines

Một tính năng chính của coroutines là chúng có thể được xâu chuỗi lại với nhau. [Hãy nhớ rằng, một đối tượng coroutine có thể chờ được, vì vậy một coroutine khác có thể

#!/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."]

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

#!/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."]

Trong thiết lập này, thời gian chạy 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."]

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
# 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ó một cấu trúc thay thế cũng có thể hoạt động với IO không đồng bộ. một số nhà sản xuất không liên kết với nhau, thêm các mục 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 theo 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 lấy đồ từ hàng đợi khi chúng xuất hiện, tham lam và không đợi bất kỳ tín hiệu nào khác

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

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

Ghi chú. Mặc dù hàng đợi thường được sử dụng trong các chương trình theo luồng vì tính an toàn của luồng là

#!/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."]

Một trường hợp sử dụng cho hàng đợi [như trường hợp ở đây] là để hàng đợi hoạt động như một bộ truyền cho nhà sản xuất và người tiêu dùng không được liên kết trực tiếp hoặc liên kết với nhau

Phiên bản đồng bộ của chương trình này trông khá ảm đạm. một nhóm các nhà sản xuất chặn thêm các mục vào hàng đợi, mỗi lần một nhà sản xuất. Chỉ sau khi tất cả các nhà sản xuất hoàn thành, 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 lấy và xử lý ngay lập tức

Phiên bản không đồ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."]