Làm thế nào để bộ đếm thời gian chủ đề làm việc python?

chủ đề daemon

Trong khoa học máy tính, một

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Python

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Nếu một chương trình đang chạy

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy xem xét kỹ hơn một chút đầu ra của chương trình của bạn ở trên. Hai dòng cuối cùng là một chút thú vị. Khi bạn chạy chương trình, bạn sẽ nhận thấy rằng có một khoảng dừng [khoảng 2 giây] sau khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Việc tạm dừng này là Python đang chờ chuỗi không phải daemon hoàn thành. Khi chương trình Python của bạn kết thúc, một phần của quy trình tắt máy là dọn sạch quy trình luồng

Nếu bạn nhìn vào , bạn sẽ thấy rằng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Vì vậy, chương trình của bạn chờ để thoát vì bản thân luồng đang chờ trong chế độ ngủ. Ngay sau khi hoàn thành và in thông báo,

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Thông thường, hành vi này là những gì bạn muốn, nhưng có các tùy chọn khác có sẵn cho chúng tôi. Trước tiên, hãy lặp lại chương trình với luồng

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Khi bạn chạy chương trình bây giờ, bạn sẽ thấy đầu ra này

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Sự khác biệt ở đây là dòng cuối cùng của đầu ra bị thiếu.

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

27 một chủ đề

Chủ đề daemon rất tiện dụng, nhưng còn khi bạn muốn đợi một chủ đề dừng lại thì sao?

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Để yêu cầu một luồng đợi một luồng khác kết thúc, bạn gọi _

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Bạn đã kiểm tra điều này trên mã bằng luồng daemon hay luồng thông thường chưa? . Nếu bạn

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

một chủ đề

Trước khi bạn đi sâu vào vấn đề này với hai luồng, hãy quay lại và nói một chút về một số chi tiết về cách hoạt động của các luồng

Bạn sẽ không đi sâu vào tất cả các chi tiết ở đây, vì điều đó không quan trọng ở cấp độ này. Chúng tôi cũng sẽ đơn giản hóa một số thứ theo cách không chính xác về mặt kỹ thuật nhưng sẽ cung cấp cho bạn ý tưởng đúng về những gì đang xảy ra

Khi bạn yêu cầu

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Kết quả của việc này là mỗi luồng trong nhóm sẽ gọi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Mỗi luồng sẽ có một tham chiếu đến cùng một đối tượng

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Khi luồng bắt đầu chạy

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Bây giờ bạn có thể bắt đầu tìm hiểu điều gì sẽ xảy ra nếu bạn chạy chương trình ở trên với một chuỗi và một cuộc gọi duy nhất tới

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Hình ảnh dưới đây hướng dẫn thực thi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Sơ đồ được bố trí sao cho thời gian tăng lên khi bạn di chuyển từ trên xuống dưới. Nó bắt đầu khi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Khi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Tiếp theo

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Khi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Càng xa càng tốt. Bạn đã chạy

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

hai chủ đề

Quay trở lại điều kiện cuộc đua, hai luồng sẽ chạy đồng thời nhưng không đồng thời. Mỗi người sẽ có phiên bản

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Chương trình bắt đầu với ________ 1504 đang chạy ________ 1509

Khi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Khi

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Hai luồng có quyền truy cập xen kẽ vào một đối tượng được chia sẻ duy nhất, ghi đè lên kết quả của nhau. Các điều kiện tương tự có thể phát sinh khi một luồng giải phóng bộ nhớ hoặc đóng một bộ xử lý tệp trước khi luồng kia truy cập xong.

Tại sao đây không phải là một ví dụ ngớ ngẩn

Ví dụ trên được tạo ra để đảm bảo rằng điều kiện chạy đua xảy ra mỗi khi bạn chạy chương trình của mình. Bởi vì hệ điều hành có thể hoán đổi một luồng bất kỳ lúc nào, nên có thể ngắt một câu lệnh như

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Các chi tiết về cách điều này xảy ra khá thú vị, nhưng không cần thiết cho phần còn lại của bài viết này, vì vậy vui lòng bỏ qua phần ẩn này

Điều này thực sự hoạt động như thế nàoHiển thị/Ẩn

Đoạn mã trên không hoàn toàn có sẵn như ban đầu bạn có thể nghĩ. Nó được thiết kế để bắt buộc một điều kiện cuộc đua mỗi khi bạn chạy nó, nhưng điều đó giúp giải quyết vấn đề dễ dàng hơn nhiều so với hầu hết các điều kiện cuộc đua

Có hai điều cần lưu ý khi nghĩ về điều kiện cuộc đua

1. Ngay cả một hoạt động như

   import threading
   
   def task[]:
       print["timer object task running..."]
   
   if __name__=='__main__':
       t = threading.Timer[10, task]
       t.start[] # after 10 seconds, task will be executed
   

   586 cũng cần bộ xử lý nhiều bước. Mỗi bước này là một hướng dẫn riêng cho bộ xử lý

2. Hệ điều hành có thể hoán đổi luồng nào đang chạy bất cứ lúc nào. Một chuỗi có thể được hoán đổi sau bất kỳ hướng dẫn nhỏ nào sau đây. Điều này có nghĩa là một luồng có thể được đặt ở chế độ ngủ để cho một luồng khác chạy ở giữa câu lệnh Python

Hãy xem xét điều này một cách chi tiết. REPL bên dưới hiển thị một hàm nhận một tham số và tăng nó

>>>

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Ví dụ REPL sử dụng

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Chúng tôi dừng lại ở đây vì một lý do cụ thể. Đây là điểm trong

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Như bạn đã tìm hiểu ở trên, hệ điều hành có thể hoán đổi luồng bất kỳ lúc nào. Bạn đã đi xuống danh sách này đến tuyên bố được đánh dấu

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Về mặt kỹ thuật, ví dụ này sẽ không có điều kiện chạy đua vì

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Rất hiếm khi xảy ra tình trạng cuộc đua như thế này, nhưng hãy nhớ rằng một sự kiện không thường xuyên xảy ra sau hàng triệu lần lặp lại sẽ có khả năng xảy ra. Sự hiếm có của các điều kiện chủng tộc này khiến chúng khó gỡ lỗi hơn nhiều so với các lỗi thông thường.

Bây giờ hãy quay lại phần hướng dẫn được lên lịch thường xuyên của bạn

Bây giờ bạn đã thấy một điều kiện chủng tộc đang hoạt động, hãy cùng tìm hiểu cách giải quyết chúng

Nhà sản xuất-Người tiêu dùng Sử dụng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

302

Vì đây là một bài viết về Python

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Thiết kế chung là có một luồng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Để tạo một tin nhắn giả mạo,

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Ở phía bên kia của

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Trước khi bạn xem phần thực sự thú vị, phần

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Điều này trông khá quen thuộc vì nó gần với mã

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy nhớ rằng bạn có thể bật ghi nhật ký

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Có thể đáng để xem qua các thông báo ghi nhật ký của

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Bây giờ chúng ta hãy xem

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

ồ. Đó là rất nhiều mã. Một tỷ lệ phần trăm khá cao trong số đó chỉ là ghi lại các câu lệnh để dễ dàng xem điều gì đang xảy ra khi bạn chạy nó. Đây là cùng một mã với tất cả các câu lệnh ghi nhật ký đã bị xóa

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Điều đó có vẻ dễ quản lý hơn một chút.

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

1. x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   385 lưu trữ tin nhắn để vượt qua

2. x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   386 là một đối tượng

   x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   387 hạn chế quyền truy cập vào tin nhắn theo luồng

   x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   363

3. x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   389 cũng là một

   x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   387 hạn chế quyền truy cập vào thư theo chuỗi

   x = threading.Thread[target=thread_function, args=[1,], daemon=True]
   

   368

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Trước khi bạn tiếp tục với

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Đây là câu trả lời. Ngay khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Chuyển sang

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy chạy mã có ghi nhật ký được đặt thành

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Lúc đầu, bạn có thể thấy lạ khi nhà sản xuất nhận được hai tin nhắn trước khi người tiêu dùng thậm chí chạy. Nếu bạn nhìn lại

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hệ điều hành có thể hoán đổi các luồng bất cứ lúc nào, nhưng nó thường cho phép mỗi luồng có một khoảng thời gian hợp lý để chạy trước khi hoán đổi nó. Đó là lý do tại sao

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Tuy nhiên, khi một luồng bị chặn, hệ điều hành sẽ luôn hoán đổi nó và tìm một luồng khác để chạy. Trong trường hợp này, chuỗi duy nhất khác có bất kỳ việc gì phải làm là

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Lưu ý rằng tin nhắn đầu tiên là

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Mặc dù nó hoạt động cho thử nghiệm hạn chế này, nhưng nó không phải là một giải pháp tuyệt vời cho vấn đề người sản xuất-người tiêu dùng nói chung vì nó chỉ cho phép một giá trị duy nhất trong quy trình tại một thời điểm. Khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy chuyển sang một cách tốt hơn để giải quyết vấn đề này, sử dụng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Nhà sản xuất-Người tiêu dùng Sử dụng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

46

Nếu bạn muốn có thể xử lý nhiều giá trị trong quy trình cùng một lúc, bạn sẽ cần cấu trúc dữ liệu cho quy trình cho phép số lượng tăng và giảm khi dữ liệu được sao lưu từ

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Thư viện chuẩn của Python có một mô-đun

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy bắt đầu với

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Việc kích hoạt sự kiện có thể là nhiều thứ. Trong ví dụ này, luồng chính sẽ đơn giản là ngủ một lúc và sau đó

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Những thay đổi duy nhất ở đây là việc tạo đối tượng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Bây giờ nó sẽ lặp lại cho đến khi thấy rằng sự kiện đã được đặt trên dòng 3. Nó cũng không còn đặt giá trị

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Trong khi bạn phải lấy mã liên quan đến giá trị ________ 2370, bạn phải thực hiện một điều kiện ________ 270 phức tạp hơn một chút. Nó không chỉ lặp cho đến khi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Đảm bảo hàng đợi trống trước khi người tiêu dùng kết thúc sẽ ngăn chặn một vấn đề thú vị khác. Nếu

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Điều này xảy ra nếu

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Nếu điều đó xảy ra, người tiêu dùng có thể thức dậy và thoát ra với hàng đợi vẫn đầy đủ. Sau đó, ________ 2363 sẽ gọi ________ 2366 sẽ đợi cho đến khi có chỗ trống trên hàng đợi cho tin nhắn mới.

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Phần còn lại của

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Tuy nhiên,

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Bạn có thể thấy rằng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Nếu bạn đưa ra một số dương cho

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Các nhà phát triển cốt lõi đã viết thư viện tiêu chuẩn biết rằng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Chạy chương trình này trông giống như sau

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Nếu bạn đọc qua đầu ra trong ví dụ của tôi, bạn có thể thấy một số điều thú vị đang xảy ra. Ngay ở trên cùng, bạn có thể thấy

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Sau đó,

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Đây là cách bạn biết rằng tin nhắn thứ năm vẫn chưa được gửi đến ________ 2367. Hàng đợi giảm xuống kích thước ba sau khi một tin nhắn bị xóa. Bạn cũng biết rằng

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Ghi chú. Đầu ra của bạn sẽ khác. Đầu ra của bạn sẽ thay đổi từ lần chạy này sang lần chạy khác. Đó là phần thú vị khi làm việc với các chủ đề

Khi chương trình bắt đầu kết thúc, bạn có thể thấy luồng chính tạo ra

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Hãy thử chơi với các kích thước hàng đợi khác nhau và các cuộc gọi tới

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Đây là một giải pháp tốt hơn nhiều cho vấn đề người sản xuất-người tiêu dùng, nhưng bạn có thể đơn giản hóa nó hơn nữa.

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Đây là mã cuối cùng trông như thế nào khi sử dụng trực tiếp

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Điều đó dễ đọc hơn và cho thấy cách sử dụng các nguyên hàm tích hợp sẵn của Python có thể đơn giản hóa một vấn đề phức tạp

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

đèn hiệu

Đối tượng Python

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Bộ đếm nội bộ được tăng lên khi bạn gọi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Thuộc tính đặc biệt tiếp theo là nếu một luồng gọi

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Semaphores thường được sử dụng để bảo vệ tài nguyên có dung lượng hạn chế. Một ví dụ sẽ là nếu bạn có một nhóm kết nối và muốn giới hạn kích thước của nhóm đó ở một số cụ thể

hẹn giờ

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

x = threading.Thread[target=thread_function, args=[1,], daemon=True]

Bạn bắt đầu

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Nếu bạn muốn dừng một

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Một

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Rào chắn

Một

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

Hãy nhớ rằng các luồng được lên lịch bởi hệ điều hành, vì vậy, mặc dù tất cả các luồng được giải phóng đồng thời, chúng sẽ được lên lịch để chạy từng luồng một

Một cách sử dụng cho

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed

import threading

def task[]:
    print["timer object task running..."]

if __name__=='__main__':
    t = threading.Timer[10, task]
    t.start[] # after 10 seconds, task will be executed