Hướng dẫn is python thread a real thread? - Chuỗi trăn có phải là một chủ đề thật không?

Question

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để làm sâu sắc thêm sự hiểu biết của bạn: Xây dựng bằng Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Threading in Python

Nội dung chính Show

Một chủ đề là gì?
Bắt đầu một chủ đề
Chủ đề daemon
import concurrent.futures # [rest of code] if __name__ == "__main__": format = "%(asctime)s: %(message)s" logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S") with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: executor.map(thread_function, range(3)) 6 Một chủ đề
Làm việc với nhiều chủ đề
Sử dụng x = threading.Thread(target=thread_function, args=(1,), daemon=True) 4
Điều kiện chủng tộc
Một chủ đề
Hai chủ đề
Tại sao đây là một ví dụ ngớ ngẩn
Đồng bộ hóa cơ bản bằng cách sử dụng x = threading.Thread(target=thread_function, args=(1,)) x.start() 98
Nhà sản xuất-người tiêu dùng
Nhà sản xuất người tiêu dùng sử dụng x = threading.Thread(target=thread_function, args=(1,)) x.start() 98
Người sản xuất người tiêu dùng sử dụng x = threading.Thread(target=thread_function, args=(1,), daemon=True) 42
Đối tượng luồng
Hẹn giờ
Rào chắn
Kết luận: Chủ đề trong Python
Python có chủ đề thật không?
Có phải chủ đề python có chủ đề hệ điều hành không?
Là chủ đề python
Có phải chủ đề Python còn sống?

Python Threading cho phép bạn có các phần khác nhau trong chương trình chạy đồng thời và có thể đơn giản hóa thiết kế của bạn. Nếu bạn đã có một số kinh nghiệm về Python và muốn tăng tốc chương trình của mình bằng cách sử dụng các chủ đề, thì hướng dẫn này là dành cho bạn!

Trong bài viết này, bạn sẽ học:

Chủ đề là gì
Cách tạo chủ đề và chờ chúng hoàn thành

Cách sử dụng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4

Làm thế nào để tránh điều kiện cuộc đua

Cách sử dụng các công cụ phổ biến mà Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5 cung cấp

Bài viết này giả định rằng bạn đã có những điều cơ bản của Python và bạn sử dụng ít nhất phiên bản 3.6 để chạy các ví dụ. Nếu bạn cần bồi dưỡng, bạn có thể bắt đầu với các đường dẫn học tập Python và tăng tốc.

Nếu bạn không chắc chắn nếu bạn muốn sử dụng Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5,

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

7 hoặc

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

8, thì bạn có thể kiểm tra tăng tốc chương trình Python của mình với sự đồng thời.

Tất cả các nguồn được sử dụng trong hướng dẫn này đều có sẵn cho bạn trong repo Python GitHub thực sự.

Một chủ đề là gì?

Một luồng là một luồng thực thi riêng biệt. Điều này có nghĩa là chương trình của bạn sẽ có hai điều xảy ra cùng một lúc. Nhưng đối với hầu hết các triển khai Python 3, các chủ đề khác nhau không thực sự thực hiện cùng một lúc: chúng chỉ xuất hiện.

Nó rất hấp dẫn khi nghĩ đến việc xâu chuỗi là có hai (hoặc nhiều) bộ xử lý khác nhau chạy trong chương trình của bạn, mỗi bộ thực hiện một nhiệm vụ độc lập cùng một lúc. Điều đó gần như đúng. Các luồng có thể đang chạy trên các bộ xử lý khác nhau, nhưng chúng sẽ chỉ chạy một lần.

Nhận được nhiều nhiệm vụ chạy đồng thời yêu cầu triển khai Python không chuẩn, viết một số mã của bạn bằng một ngôn ngữ khác hoặc sử dụng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

8 đi kèm với một số chi phí bổ sung.

Do cách thực hiện CPython của Python hoạt động, việc xâu chuỗi có thể không tăng tốc tất cả các nhiệm vụ. Điều này là do các tương tác với GIL về cơ bản giới hạn một luồng python để chạy tại một thời điểm.

Các nhiệm vụ dành phần lớn thời gian của họ để chờ đợi các sự kiện bên ngoài nói chung là những ứng cử viên tốt để tham gia. Các vấn đề yêu cầu tính toán CPU nặng và dành ít thời gian chờ đợi các sự kiện bên ngoài có thể không chạy nhanh hơn chút nào.

Điều này đúng với mã được viết bằng Python và chạy trên triển khai CPython tiêu chuẩn. Nếu chủ đề của bạn được viết bằng C, chúng có khả năng giải phóng Gil và chạy đồng thời. Nếu bạn đang chạy trên một triển khai Python khác, hãy kiểm tra với tài liệu cũng xem cách nó xử lý các chủ đề.

Nếu bạn đang chạy một triển khai Python tiêu chuẩn, chỉ viết bằng Python và có vấn đề ràng buộc CPU, bạn nên kiểm tra mô-đun

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

8 thay thế.

Kiến trúc chương trình của bạn để sử dụng luồng cũng có thể cung cấp lợi ích trong thiết kế rõ ràng. Hầu hết các ví dụ mà bạn sẽ tìm hiểu trong hướng dẫn này không nhất thiết sẽ chạy nhanh hơn vì chúng sử dụng các chủ đề. Sử dụng luồng trong chúng giúp làm cho thiết kế sạch hơn và dễ lý luận hơn.

Vì vậy, hãy để Lôi ngừng nói về việc xâu chuỗi và bắt đầu sử dụng nó!

Bắt đầu một chủ đề

Bây giờ, bạn đã có một ý tưởng về một chủ đề là gì, hãy để học cách tạo ra một chủ đề. Thư viện tiêu chuẩn Python cung cấp

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5, trong đó chứa hầu hết các nguyên thủy mà bạn sẽ thấy trong bài viết này.

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2, trong mô -đun này, đóng gói độc đáo các chủ đề, cung cấp một giao diện sạch để làm việc với chúng.

Để bắt đầu một luồng riêng biệt, bạn tạo một thể hiện

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2 và sau đó nói với

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

4:

 1import logging
 2import threading
 3import time
 4
 5def thread_function(name):
 6    logging.info("Thread %s: starting", name)
 7    time.sleep(2)
 8    logging.info("Thread %s: finishing", name)
 9
10if __name__ == "__main__":
11    format = "%(asctime)s: %(message)s"
12    logging.basicConfig(format=format, level=logging.INFO,
13                        datefmt="%H:%M:%S")
14
15    logging.info("Main    : before creating thread")
16    x = threading.Thread(target=thread_function, args=(1,))
17    logging.info("Main    : before running thread")
18    x.start()
19    logging.info("Main    : wait for the thread to finish")
20    # x.join()
21    logging.info("Main    : all done")

Nếu bạn nhìn xung quanh các câu lệnh ghi nhật ký, bạn có thể thấy phần

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

5 đang tạo và bắt đầu luồng:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

Khi bạn tạo

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2, bạn chuyển nó một hàm và một danh sách chứa các đối số cho hàm đó. Trong trường hợp này, bạn đã nói với

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2 chạy

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

8 và vượt qua nó

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

9 như một cuộc tranh luận.

Đối với bài viết này, bạn sẽ sử dụng các số nguyên tuần tự làm tên cho các chủ đề của bạn. Có

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

0, trả về một tên duy nhất cho mỗi luồng, nhưng chúng thường không ngắn cũng không dễ đọc.

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

8 bản thân nó không làm nhiều. Nó chỉ đơn giản là ghi lại một số tin nhắn với

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

2 ở giữa chúng.

Khi bạn chạy chương trình này như hiện tại (với dòng hai mươi nhận xét), đầu ra sẽ trông như thế này:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

Bạn sẽ nhận thấy rằng

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2 đã hoàn thành sau phần

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

4 trong mã của bạn đã làm. Bạn sẽ quay lại lý do tại sao và nói về dòng bí ẩn hai mươi trong phần tiếp theo.

Chủ đề daemon

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

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5 là một quá trình chạy trong nền.

Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5 có ý nghĩa cụ thể hơn cho

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5. Một luồng

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5 sẽ tắt ngay lập tức khi chương trình thoát ra. Một cách để suy nghĩ về các định nghĩa này là xem xét chuỗi

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5 Một luồng chạy trong nền mà không phải lo lắng về việc tắt nó xuống.

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

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

0 không phải là

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

1, thì chương trình sẽ đợi các luồng đó hoàn thành trước khi kết thúc.

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

0 là daemon, tuy nhiên, chỉ bị giết bất cứ nơi nào khi họ đang xuất hiện.

Hãy cùng xem xét kỹ hơn một chút về đầu ra của chương trình của bạn ở trên. Hai dòng cuối cùng là bit 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

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3 đã in tin nhắn

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

4 của nó và trước khi chủ đề kết thúc.

Tạm dừng này là Python chờ đợi chủ đề không hoàn thành. Khi chương trình Python của bạn kết thúc, một phần của quá trình tắt máy là làm sạch thói quen luồng.

Nếu bạn nhìn vào nguồn cho Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5, bạn sẽ thấy rằng

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

6 đi qua tất cả các luồng đang chạy và gọi

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7 trên mỗi cái không có đặt cờ

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5.

Vì vậy, chương trình của bạn chờ đợi để thoát vì chính chủ đề đang chờ trong một giấc ngủ. Ngay sau khi hoàn thành và in tin nhắn,

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7 sẽ trở lại và chương trình có thể thoát.

Thông thường, hành vi này là những gì bạn muốn, nhưng có những 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 chủ đề

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5. Bạn làm điều đó bằng cách thay đổi cách bạn xây dựng

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2, thêm cờ

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

2:

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

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

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

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

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

8 không có cơ hội hoàn thành. Đó là một chủ đề

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

5, vì vậy khi

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3 đi đến cuối mã của nó và chương trình muốn hoàn thành, daemon đã bị giết.

import concurrent.futures # [rest of code] if name == "main": format = "%(asctime)s: %(message)s" logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S") with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: executor.map(thread_function, range(3)) 6 Một chủ đề

Chủ đề daemon rất tiện dụng, nhưng khi nào bạn muốn đợi một chủ đề dừng lại? Thế còn khi bạn muốn làm điều đó và không thoát khỏi chương trình của bạn? Bây giờ, hãy để Lừa quay trở lại chương trình ban đầu của bạn và xem xét điều đó đã nhận xét về dòng hai mươi:

Để nói với một chủ đề để đợi một chủ đề khác kết thúc, bạn gọi

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7. Nếu bạn giải quyết dòng đó, luồng chính sẽ tạm dừng và chờ luồng

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8 hoàn thành chạy.

Bạn đã kiểm tra điều này trên mã với luồng daemon hoặc luồng thông thường? Hóa ra nó không quan trọng. Nếu bạn

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7 một chủ đề, câu lệnh đó sẽ đợi cho đến khi một loại luồng được hoàn thành.

Làm việc với nhiều chủ đề

Mã ví dụ cho đến nay chỉ hoạt động với hai luồng: luồng chính và một luồng bạn bắt đầu với đối tượng

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

0.

Thông thường, bạn sẽ muốn bắt đầu một số chủ đề và yêu cầu chúng làm công việc thú vị. Hãy bắt đầu bằng cách nhìn vào cách làm điều đó khó hơn, và sau đó bạn sẽ chuyển sang một phương pháp dễ dàng hơn.

Cách khó hơn để bắt đầu nhiều luồng là cách mà bạn đã biết:

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

Mã này sử dụng cùng một cơ chế mà bạn đã thấy ở trên để bắt đầu một luồng, tạo đối tượng

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2 và sau đó gọi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

4. Chương trình giữ một danh sách các đối tượng

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

2 để sau đó có thể đợi chúng sau đó bằng cách sử dụng

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7.

Chạy mã này nhiều lần có thể sẽ tạo ra một số kết quả thú vị. Ở đây, một ví dụ đầu ra từ máy của tôi:

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

Nếu bạn đi qua đầu ra một cách cẩn thận, bạn sẽ thấy cả ba chủ đề bắt đầu theo thứ tự bạn có thể mong đợi, nhưng trong trường hợp này, chúng kết thúc theo thứ tự ngược lại! Nhiều lần chạy sẽ tạo ra các thứ tự khác nhau. Tìm tin nhắn

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

5 để cho bạn biết khi mỗi chủ đề hoàn thành.

Thứ tự mà các luồng được chạy được xác định bởi hệ điều hành và có thể khá khó dự đoán. Nó có thể (và có thể sẽ) thay đổi từ chạy đến chạy, vì vậy bạn cần nhận thức được điều đó khi bạn thiết kế các thuật toán sử dụng luồng.

May mắn thay, Python cung cấp cho bạn một số nguyên thủy mà bạn sẽ xem xét sau này để giúp phối hợp các luồng và khiến chúng chạy cùng nhau. Trước đó, hãy để Lôi nhìn vào cách làm cho việc quản lý một nhóm các chủ đề dễ dàng hơn một chút.

Sử dụng x = threading.Thread(target=thread_function, args=(1,), daemon=True) 4

Có một cách dễ dàng hơn để bắt đầu một nhóm các chủ đề so với cái bạn thấy ở trên. Nó được gọi là

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4, và nó là một phần của thư viện tiêu chuẩn trong

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

8 (kể từ Python 3.2).

Cách dễ nhất để tạo nó là một người quản lý bối cảnh, sử dụng tuyên bố

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

9 để quản lý việc tạo và phá hủy nhóm.

Tại đây,

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3 từ ví dụ cuối cùng được viết lại để sử dụng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4:

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

Mã tạo ra

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4 như một người quản lý bối cảnh, cho biết nó có bao nhiêu chủ đề công nhân muốn trong nhóm. Sau đó, nó sử dụng

class FakeDatabase:
    def __init__(self):
        self.value = 0

    def update(self, name):
        logging.info("Thread %s: starting update", name)
        local_copy = self.value
        local_copy += 1
        time.sleep(0.1)
        self.value = local_copy
        logging.info("Thread %s: finishing update", name)

3 để bước qua một số thứ khác, trong trường hợp của bạn

class FakeDatabase:
    def __init__(self):
        self.value = 0

    def update(self, name):
        logging.info("Thread %s: starting update", name)
        local_copy = self.value
        local_copy += 1
        time.sleep(0.1)
        self.value = local_copy
        logging.info("Thread %s: finishing update", name)

4, chuyển từng cái một luồng trong nhóm.

Phần cuối của khối

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

9 khiến

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4 thực hiện

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7 trên mỗi luồng trong nhóm. Chúng tôi khuyên bạn nên sử dụng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4 như một trình quản lý ngữ cảnh khi bạn có thể để bạn không bao giờ quên

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

7 các chủ đề.

Chạy mã ví dụ đã sửa của bạn sẽ tạo ra đầu ra trông như thế này:

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

Một lần nữa, hãy chú ý cách

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 kết thúc trước

x = threading.Thread(target=thread_function, args=(1,))
x.start()

01. Việc lập lịch trình của các chủ đề được thực hiện bởi hệ điều hành và không tuân theo một kế hoạch mà dễ dàng tìm ra.

Điều kiện chủng tộc

Trước khi bạn chuyển sang một số tính năng khác được giấu trong Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5, hãy để Lừa nói một chút về một trong những vấn đề khó khăn hơn mà bạn sẽ gặp phải khi viết các chương trình được thực hiện: Điều kiện cuộc đua.

Khi bạn đã thấy một điều kiện cuộc đua là gì và nhìn vào một người xảy ra, bạn sẽ chuyển sang một số nguyên thủy được cung cấp bởi thư viện tiêu chuẩn để ngăn chặn các điều kiện chủng tộc xảy ra.

Điều kiện cuộc đua có thể xảy ra khi hai hoặc nhiều luồng truy cập một phần dữ liệu hoặc tài nguyên được chia sẻ. Trong ví dụ này, bạn sẽ tạo ra một điều kiện cuộc đua lớn xảy ra mọi lúc, nhưng lưu ý rằng hầu hết các điều kiện chủng tộc không rõ ràng như vậy. Thông thường, chúng chỉ xảy ra hiếm khi và chúng có thể tạo ra kết quả khó hiểu. Như bạn có thể tưởng tượng, điều này làm cho chúng khá khó để gỡ lỗi.

May mắn thay, điều kiện cuộc đua này sẽ xảy ra mỗi lần và bạn sẽ đi qua nó một cách chi tiết để giải thích những gì đang xảy ra.

Trong ví dụ này, bạn sẽ viết một lớp cập nhật cơ sở dữ liệu. Được rồi, bạn không thực sự sẽ có một cơ sở dữ liệu: bạn sẽ chỉ giả mạo nó, bởi vì đó không phải là điểm của bài viết này.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03 của bạn sẽ có các phương pháp

x = threading.Thread(target=thread_function, args=(1,))
x.start()

04 và

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05:

class FakeDatabase:
    def __init__(self):
        self.value = 0

    def update(self, name):
        logging.info("Thread %s: starting update", name)
        local_copy = self.value
        local_copy += 1
        time.sleep(0.1)
        self.value = local_copy
        logging.info("Thread %s: finishing update", name)

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03 đang theo dõi một số duy nhất:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07. Đây sẽ là dữ liệu được chia sẻ mà bạn sẽ thấy điều kiện cuộc đua.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

04 Đơn giản chỉ cần khởi tạo

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07 đến 0. Càng xa càng tốt.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 trông hơi lạ. Nó mô phỏng việc đọc một giá trị từ cơ sở dữ liệu, thực hiện một số tính toán trên nó và sau đó viết một giá trị mới trở lại cơ sở dữ liệu.

Trong trường hợp này, đọc từ cơ sở dữ liệu chỉ có nghĩa là sao chép

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07 sang biến cục bộ. Việc tính toán chỉ là để thêm một vào giá trị và sau đó

x = threading.Thread(target=thread_function, args=(1,))
x.start()

12 cho một chút. Cuối cùng, nó ghi lại giá trị bằng cách sao chép giá trị cục bộ trở lại

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07.

Đây là cách bạn sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03 này:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

0

Chương trình tạo ra một

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4 với hai luồng và sau đó gọi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

16 trên mỗi người trong số họ, bảo họ chạy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

17.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

16 có chữ ký cho phép cả đối số vị trí và được đặt tên được chuyển đến hàm chạy trong luồng:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

1

Trong việc sử dụng ở trên,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

19 được thông qua là đối số vị trí đầu tiên và duy nhất cho

x = threading.Thread(target=thread_function, args=(1,))
x.start()

17. Bạn sẽ thấy sau trong bài viết này, nơi bạn có thể vượt qua nhiều đối số theo cách tương tự.

Vì mỗi luồng chạy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 và

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 thêm một vào

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07, bạn có thể mong đợi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 là

x = threading.Thread(target=thread_function, args=(1,))
x.start()

25 khi nó được in ra ở cuối. Nhưng bạn sẽ không xem xét ví dụ này nếu đó là trường hợp. Nếu bạn chạy mã trên, đầu ra trông như thế này:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

2

Bạn có thể đã mong đợi điều đó sẽ xảy ra, nhưng hãy để Lôi nhìn vào các chi tiết về những gì mà thực sự đang diễn ra ở đây, vì điều đó sẽ làm cho giải pháp cho vấn đề này dễ hiểu hơn.

Một chủ đề

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

Bạn đã giành chiến thắng khi đ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 vài điều theo cách mà giành được chính xác về mặt kỹ thuật nhưng sẽ cho bạn ý tưởng đúng về những gì đang xảy ra.

Khi bạn nói với

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

4 của mình để chạy từng luồng, bạn sẽ cho nó biết chức năng nào sẽ chạy và những tham số nào sẽ truyền cho nó:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

27.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

28. Lưu ý rằng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

29 là một tham chiếu đến đối tượng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03 được tạo trong

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3. Gọi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 trên đối tượng đó gọi một phương thức thể hiện trên đối tượng đó.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

29. Mỗi luồng cũng sẽ có một giá trị duy nhất,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

19, để làm cho các câu lệnh ghi nhật ký dễ đọc hơn một chút:

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05, nó có phiên bản riêng của tất cả dữ liệu cục bộ cho chức năng. Trong trường hợp của

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05, đây là

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38. Đây chắc chắn là một điều tốt. Nếu không, hai luồng chạy cùng một chức năng sẽ luôn gây nhầm lẫn cho nhau. Nó có nghĩa là tất cả các biến được phạm vi (hoặc cục bộ) đến một hàm đều an toàn.local to the function. In the case of

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05, this is

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38. This is definitely a good thing. Otherwise, two threads running the same function would always confuse each other. It means that all variables that are scoped (or local) to a function are thread-safe.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05.

Hình ảnh bên dưới bước thông qua việc thực hiện

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 nếu chỉ chạy một luồng. Câu lệnh được hiển thị ở bên trái theo sau là sơ đồ hiển thị các giá trị trong luồng ____ ____ ____138 và

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 được chia sẻ:

Hướng dẫn is python thread a real thread? - Chuỗi trăn có phải là một chủ đề thật không?

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 được tạo và kết thúc khi nó bị chấm dứt.

Khi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 bắt đầu,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

45 bằng không. Dòng mã đầu tiên trong phương thức,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

46, sao chép giá trị 0 vào biến cục bộ. Tiếp theo, nó tăng giá trị của

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 với câu lệnh

x = threading.Thread(target=thread_function, args=(1,))
x.start()

48. Bạn có thể thấy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

07 trong

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 được đặt thành một.

Tiếp theo

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

2 được gọi, làm cho tạm dừng luồng hiện tại và cho phép các luồng khác chạy. Vì chỉ có một chủ đề trong ví dụ này, điều này không có hiệu lực.

Khi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 thức dậy và tiếp tục, nó sao chép giá trị mới từ

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 lên

x = threading.Thread(target=thread_function, args=(1,))
x.start()

45, và sau đó luồng hoàn tất. Bạn có thể thấy rằng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 được đặt thành một.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 một lần và

x = threading.Thread(target=thread_function, args=(1,))
x.start()

45 đã được tăng lên một.

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 cùng một lúc. Mỗi người sẽ có phiên bản riêng của họ là

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 và mỗi người sẽ chỉ ra cùng một

x = threading.Thread(target=thread_function, args=(1,))
x.start()

29. Chính đối tượng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

29 được chia sẻ này sẽ gây ra các vấn đề.

Chương trình bắt đầu với

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 đang chạy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05:

Khi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 gọi

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

2, nó cho phép luồng khác bắt đầu chạy. Đây là nơi mà mọi thứ trở nên thú vị.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

65 bắt đầu và thực hiện các hoạt động tương tự. Nó cũng sao chép

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 vào riêng tư

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 và điều này đã chia sẻ

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 chưa được cập nhật:

Khi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

65 cuối cùng đi ngủ,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 được chia sẻ vẫn chưa được sửa đổi ở mức 0 và cả hai phiên bản riêng của

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 đều có giá trị một.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 hiện thức dậy và lưu phiên bản

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 và sau đó chấm dứt, cho

x = threading.Thread(target=thread_function, args=(1,))
x.start()

65 cơ hội cuối cùng để chạy.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

65 không biết rằng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 đã chạy và cập nhật

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24 trong khi nó đang ngủ. Nó lưu trữ phiên bản

x = threading.Thread(target=thread_function, args=(1,))
x.start()

38 của nó vào

x = threading.Thread(target=thread_function, args=(1,))
x.start()

24, cũng đặt nó thành một:

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 cuộc đua tương tự có thể phát sinh khi một luồng giải phóng bộ nhớ hoặc đóng tay cầm tệp trước khi luồng khác được truy cập xong.

Tại sao đây 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 cuộc đ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ể trao đổi một luồng bất cứ lúc nào, nên có thể làm gián đoạn một câu lệnh như

x = threading.Thread(target=thread_function, args=(1,))
x.start()

80 sau khi nó đã đọc giá trị của

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8 nhưng trước khi nó viết lại giá trị tăng.

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 hãy thoải mái bỏ qua phần ẩn này.

Mã trên không phải là ngoài đó như bạn có thể nghĩ ban đầu. Nó được thiết kế để buộc một điều kiện chủng tộc mỗi khi bạn chạy nó, nhưng điều đó giúp giải quyết dễ dàng hơn nhiều so với hầu hết các điều kiện chủng tộc.

Có hai điều cần ghi nhớ khi nghĩ về điều kiện chủng tộc:

Ngay cả một hoạt động như
```
x = threading.Thread(target=thread_function, args=(1,))
x.start()
```
82 cũng có 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ý.
Hệ điều hành có thể hoán đổi chủ đề nào đang chạy bất cứ lúc nào. Một chủ đề có thể được hoán đổi sau bất kỳ hướng dẫn nhỏ nào. Điều này có nghĩa là một chủ đề có thể được đưa vào giấc ngủ để cho một chủ đề khác chạy ở giữa một câu lệnh Python.

Hãy cùng nhìn vào điều này một cách chi tiết. REP REP bên dưới hiển thị một hàm có tham số và gia tăng nó:

>>>

x = threading.Thread(target=thread_function, args=(1,))
x.start()

3

Ví dụ thay thế sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

83 từ thư viện tiêu chuẩn Python để hiển thị các bước nhỏ hơn mà bộ xử lý thực hiện để thực hiện chức năng của bạn. Nó thực hiện một

x = threading.Thread(target=thread_function, args=(1,))
x.start()

84 của giá trị dữ liệu

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8, nó thực hiện một

x = threading.Thread(target=thread_function, args=(1,))
x.start()

86, và sau đó nó sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

87 để thêm các giá trị đó lại với nhau.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

05 ở trên khi

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

2 buộc các luồng phải chuyển đổi. Hoàn toàn có thể, thỉnh thoảng, hệ điều hành sẽ chuyển đổi các luồng tại điểm chính xác đó ngay cả khi không có

x = threading.Thread(target=thread_function, args=(1,))
x.start()

90, nhưng cuộc gọi đến

x = threading.Thread(target=thread_function, args=(1,))
x.start()

90 làm cho nó xảy ra mỗi lần.

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

92. Nếu hệ điều hành trao đổi luồng này và chạy một luồng khác cũng sửa đổi

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8, thì khi luồng này tiếp tục, nó sẽ ghi đè lên

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8 với giá trị không chính xác.

Về mặt kỹ thuật, ví dụ này đã giành được một điều kiện cuộc đua vì

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))

8 là địa phương đến

x = threading.Thread(target=thread_function, args=(1,))
x.start()

96. Tuy nhiên, nó minh họa làm thế nào một luồng có thể bị gián đoạn trong một hoạt động Python duy nhất. Cùng một tải, sửa đổi, tập hợp các hoạt động cũng xảy ra trên các giá trị toàn cầu và được chia sẻ. Bạn có thể khám phá với mô -đun

x = threading.Thread(target=thread_function, args=(1,))
x.start()

83 và tự chứng minh điều đó.

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

Bây giờ trở lại hướng dẫn theo lịch trình thường xuyên của bạn!

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

Đồng bộ hóa cơ bản bằng cách sử dụng x = threading.Thread(target=thread_function, args=(1,)) x.start() 98

Có một số cách để tránh hoặc giải quyết các điều kiện chủng tộc. Bạn đã giành chiến thắng nhìn vào tất cả chúng ở đây, nhưng có một cặp được sử dụng thường xuyên. Hãy bắt đầu với

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98.

Để giải quyết điều kiện cuộc đua của bạn ở trên, bạn cần tìm cách chỉ cho phép một luồng tại một thời điểm vào phần đọc biến đổi-viết trong mã của bạn. Cách phổ biến nhất để làm điều này được gọi là

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 trong Python. Trong một số ngôn ngữ khác, ý tưởng tương tự này được gọi là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

01. Mutex xuất phát từ loại trừ lẫn nhau, đó chính xác là những gì

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 làm.

Một

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 là một đối tượng hoạt động giống như một đường chuyền hội trường. Chỉ có một luồng tại một thời điểm có thể có

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98. Bất kỳ chủ đề nào khác muốn

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 phải đợi cho đến khi chủ sở hữu của

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 đưa nó lên.

Các chức năng cơ bản để làm điều này là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08. Một chủ đề sẽ gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

09 để lấy khóa. Nếu khóa đã được giữ, luồng gọi sẽ đợi cho đến khi nó được phát hành. Có một điểm quan trọng ở đây. Nếu một chủ đề nhận được khóa nhưng không bao giờ trả lại, chương trình của bạn sẽ bị kẹt. Bạn sẽ đọc thêm về điều này sau.

May mắn thay, Python sườn

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 cũng sẽ hoạt động như một người quản lý ngữ cảnh, vì vậy bạn có thể sử dụng nó trong một câu lệnh

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

9 và nó được phát hành tự động khi khối

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

9 thoát ra vì bất kỳ lý do gì.

Hãy cùng nhìn vào

x = threading.Thread(target=thread_function, args=(1,))
x.start()

03 với

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 được thêm vào nó. Hàm gọi vẫn giữ nguyên:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

4

Khác với việc thêm một loạt các bản ghi nhật ký để bạn có thể thấy khóa rõ ràng hơn, thay đổi lớn ở đây là thêm một thành viên có tên là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

15, đó là một đối tượng

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

16.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

15 này được khởi tạo ở trạng thái không khóa và bị khóa và phát hành bởi tuyên bố

$ ./executor.py
Thread 0: starting
Thread 1: starting
Thread 2: starting
Thread 1: finishing
Thread 0: finishing
Thread 2: finishing

9.

Ở đây, điều đáng chú ý ở đây là luồng chạy chức năng này sẽ giữ được

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 đó cho đến khi nó hoàn toàn cập nhật cơ sở dữ liệu. Trong trường hợp này, điều đó có nghĩa là nó sẽ giữ

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 trong khi nó sao chép, cập nhật, ngủ và sau đó ghi giá trị trở lại cơ sở dữ liệu.

Nếu bạn chạy phiên bản này với việc đăng nhập được đặt thành cấp cảnh báo, bạn sẽ thấy điều này:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

5

Nhìn kìa. Chương trình của bạn cuối cùng cũng hoạt động!

Bạn có thể bật đăng nhập đầy đủ bằng cách đặt cấp độ thành

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21 bằng cách thêm câu lệnh này sau khi bạn định cấu hình đầu ra ghi nhật ký trong

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

6

Chạy chương trình này với việc ghi nhật ký

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21 có vẻ như thế này:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

7

Trong đầu ra này, bạn có thể thấy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

01 có được khóa và vẫn đang giữ nó khi nó đi ngủ.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 sau đó bắt đầu và cố gắng để có được cùng một khóa. Bởi vì

x = threading.Thread(target=thread_function, args=(1,))
x.start()

01 vẫn đang giữ nó,

x = threading.Thread(target=thread_function, args=(1,))
x.start()

00 phải chờ đợi. Đây là loại trừ lẫn nhau mà

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 cung cấp.

Nhiều ví dụ trong phần còn lại của bài viết này sẽ có mức ghi nhật ký

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

29 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21. Chúng tôi thường chỉ hiển thị đầu ra cấp

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

29, vì nhật ký

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21 có thể khá dài. Hãy thử các chương trình với việc đăng nhập bật lên và xem những gì họ làm.

Bế tắc

Trước khi bạn tiếp tục, bạn nên xem xét một vấn đề phổ biến khi sử dụng

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

33. Như bạn đã thấy, nếu

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 đã được mua lại, cuộc gọi thứ hai đến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07 sẽ đợi cho đến khi luồng đang giữ cuộc gọi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08. Bạn nghĩ điều gì xảy ra khi bạn chạy mã này:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

8

Khi chương trình gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

38 lần thứ hai, nó đã chờ đợi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 được phát hành. Trong ví dụ này, bạn có thể sửa chữa bế tắc bằng cách xóa cuộc gọi thứ hai, nhưng bế tắc thường xảy ra từ một trong hai điều tinh tế:

Một lỗi thực hiện trong đó
```
x = threading.Thread(target=thread_function, args=(1,))
x.start()
```
98 không được phát hành đúng cách
Một vấn đề thiết kế trong đó một chức năng tiện ích cần được gọi bởi các chức năng có thể hoặc chưa có
```
x = threading.Thread(target=thread_function, args=(1,))
x.start()
```
98

Tình huống đầu tiên đôi khi xảy ra, nhưng sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 làm người quản lý bối cảnh làm giảm đáng kể mức độ thường xuyên. Bạn nên viết mã bất cứ khi nào có thể sử dụng các nhà quản lý ngữ cảnh, vì họ giúp tránh các tình huống trong đó một ngoại lệ bỏ qua cuộc gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08.

Vấn đề thiết kế có thể là một chút khó khăn hơn trong một số ngôn ngữ. Rất may, luồng Python có một đối tượng thứ hai, được gọi là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

44, được thiết kế cho tình huống này. Nó cho phép một luồng đến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

44 nhiều lần trước khi gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08. Chủ đề đó vẫn được yêu cầu gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 cùng một số lần được gọi là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07, nhưng dù sao nó cũng nên làm điều đó.

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

44 là hai trong số các công cụ cơ bản được sử dụng trong lập trình ren để ngăn chặn các điều kiện chủng tộc. Có một vài hoạt động khác theo những cách khác nhau. Trước khi bạn nhìn vào chúng, hãy để Lừa chuyển sang một miền vấn đề hơi khác.

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

Vấn đề của nhà sản xuất là một vấn đề khoa học máy tính tiêu chuẩn được sử dụng để xem xét các vấn đề đồng bộ hóa luồng hoặc quy trình. Bạn sẽ xem xét một biến thể của nó để có được một số ý tưởng về những gì nguyên thủy mà mô -đun Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5 cung cấp.

Trong ví dụ này, bạn sẽ tưởng tượng một chương trình cần đọc tin nhắn từ mạng và viết chúng vào đĩa. Chương trình không yêu cầu một tin nhắn khi nó muốn. Nó phải được lắng nghe và chấp nhận tin nhắn khi chúng đến. Các tin nhắn sẽ không đến với tốc độ thường xuyên, nhưng sẽ đến trong các vụ nổ. Phần này của chương trình được gọi là nhà sản xuất.

Mặt khác, một khi bạn có một tin nhắn, bạn cần viết nó vào cơ sở dữ liệu. Truy cập cơ sở dữ liệu chậm, nhưng đủ nhanh để theo kịp tốc độ trung bình của tin nhắn. Nó không đủ nhanh để theo kịp khi một loạt các tin nhắn xuất hiện. Phần này là người tiêu dùng.

Ở giữa nhà sản xuất và người tiêu dùng, bạn sẽ tạo ra một

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 sẽ là phần thay đổi khi bạn tìm hiểu về các đối tượng đồng bộ hóa khác nhau.

Đó là bố cục cơ bản. Hãy cùng nhìn vào một giải pháp bằng cách sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98. Nó không hoạt động hoàn hảo, nhưng nó sử dụng các công cụ mà bạn đã biết, vì vậy nó là một nơi tốt để bắt đầu.

Nhà sản xuất người tiêu dùng sử dụng x = threading.Thread(target=thread_function, args=(1,)) x.start() 98

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5, và vì bạn vừa đọc về nguyên thủy

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98, chúng ta hãy cố gắng giải quyết vấn đề này bằng hai luồng bằng cách sử dụng

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 hoặc hai.

Thiết kế chung là có một chuỗi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 đọc từ mạng giả và đặt thông điệp vào một

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53:

x = threading.Thread(target=thread_function, args=(1,))
x.start()

9

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 có số ngẫu nhiên từ một đến một trăm. Nó gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62 trên

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63 để gửi nó đến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 cũng sử dụng giá trị

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

66 để báo hiệu cho người tiêu dùng dừng sau khi nó đã gửi mười giá trị. Đây là một chút khó xử, nhưng đừng lo lắng, bạn sẽ thấy cách để thoát khỏi giá trị

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

66 này sau khi bạn làm việc trong ví dụ này.

Ở phía bên kia của

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63 là người tiêu dùng:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

0

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đọc một thông báo từ

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63 và ghi nó vào cơ sở dữ liệu giả, trong trường hợp này chỉ đang in nó vào màn hình. Nếu nó nhận được giá trị

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

66, nó sẽ trả về từ hàm, sẽ chấm dứt luồng.

Trước khi bạn nhìn vào phần thực sự thú vị,

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53, ở đây, phần

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3, tạo ra các chủ đề này:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

1

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

$ ./multiple_threads.py
Main    : create and start thread 0.
Thread 0: starting
Main    : create and start thread 1.
Thread 1: starting
Main    : create and start thread 2.
Thread 2: starting
Main    : before joining thread 0.
Thread 2: finishing
Thread 1: finishing
Thread 0: finishing
Main    : thread 0 done
Main    : before joining thread 1.
Main    : thread 1 done
Main    : before joining thread 2.
Main    : thread 2 done

3 trong các ví dụ trước.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21 đăng nhập để xem tất cả các tin nhắn ghi nhật ký bằng cách không đưa ra dòng này:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

2

Có thể đáng để đi qua các tin nhắn đăng nhập

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

21 để xem chính xác nơi mỗi luồng thu và phát hành các khóa.

Bây giờ, hãy để Lừa xem

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 chuyển tin nhắn từ

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 đến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

3

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

4

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 trong phiên bản mã của bạn có ba thành viên:

$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
81 lưu trữ thông điệp để vượt qua. stores the message to pass.

$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
82 là đối tượng
$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
83 hạn chế quyền truy cập vào thông báo bằng chuỗi
$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
59. is a

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

83 object that restricts access to the message by the

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 thread.

$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
85 cũng là một
$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
83 hạn chế quyền truy cập vào thông báo bằng chuỗi
$ ./single_thread.py Main : before creating thread Main : before running thread Thread 1: starting Main : wait for the thread to finish Main : all done Thread 1: finishing
64. is also a

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

83 that restricts access to the message by the

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 thread.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

88 khởi tạo ba thành viên này và sau đó gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07 trên

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

85. Đây là trạng thái bạn muốn bắt đầu.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 được phép thêm một tin nhắn mới, nhưng

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 cần phải đợi cho đến khi có tin nhắn.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

93 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

94 gần như đối lập.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

93 gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07 trên

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

97. Đây là cuộc gọi sẽ làm cho

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đợi cho đến khi một tin nhắn đã sẵn sàng.

Khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đã có được

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

85, nó sẽ sao chép giá trị trong

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

81 và sau đó gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 trên

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

82. Phát hành khóa này là những gì cho phép

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 chèn tin nhắn tiếp theo vào

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62, có một điều gì đó tinh tế đang diễn ra trong

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

93 mà khá dễ bỏ lỡ. Nó có vẻ hấp dẫn khi loại bỏ

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

08 và chỉ có chức năng kết thúc với

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

09. Xem nếu bạn có thể tìm ra lý do tại sao bạn không muốn làm điều đó trước khi tiếp tục.

Ở đây, câu trả lời. Ngay khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 gọi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

11, nó có thể được hoán đổi và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 có thể bắt đầu chạy. Điều đó có thể xảy ra trước khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 trở lại! Điều này có nghĩa là có một khả năng nhỏ là khi hàm trả về

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

14, đó thực sự có thể là thông báo tiếp theo được tạo, vì vậy bạn sẽ mất tin nhắn đầu tiên. Đây là một ví dụ khác về một điều kiện chủng tộc.

Chuyển sang

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62, bạn có thể thấy phía đối diện của giao dịch.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 sẽ gọi cái này với một tin nhắn. Nó sẽ có được

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

82, đặt

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

81 và cuộc gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 vào lúc đó

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

97, sẽ cho phép

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đọc giá trị đó.

Hãy cùng chạy mã có bộ ghi nhật ký thành

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

29 và xem nó trông như thế nào:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

5

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62, bạn sẽ nhận thấy rằng nơi duy nhất nó sẽ chờ đợi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 là khi nó cố gắng đưa tin nhắn vào đường ống. Điều này được thực hiện sau khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 nhận được tin nhắn và nhật ký rằng nó có nó.

Khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 cố gắng gửi tin nhắn thứ hai này, nó sẽ gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62 lần thứ hai và nó sẽ chặn.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 thường chạy cho đến khi nó chặn trong cuộc gọi thứ hai đến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

93, đọc tin nhắn và gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 trên

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

82, do đó cho phép

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 chạy lại vào thời gian tiếp theo được hoán đổi.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

37 và đó chính xác là những gì

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đã đọc, mặc dù

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 đã tạo ra thông báo

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

40.

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 tiêu dùng sản xuất nói chung vì nó chỉ cho phép một giá trị duy nhất trong đường ống tại một thời điểm. Khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 nhận được một tin nhắn, nó sẽ không có nơi nào để đặt chúng.

Hãy cùng 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)

42.

Người sản xuất người tiêu dùng sử dụng x = threading.Thread(target=thread_function, args=(1,), daemon=True) 42

Nếu bạn muốn có thể xử lý nhiều hơn một giá trị trong đường ống tại một thời điểm, bạn sẽ cần một cấu trúc dữ liệu cho đường ống cho phép số phát triển và thu nhỏ khi dữ liệu tăng từ

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59.

Thư viện tiêu chuẩn Python sườn có mô -đun

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

45, do đó, có lớp

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42. Hãy để thay đổi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 để sử dụng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42 thay vì chỉ là một biến được bảo vệ bởi

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98. Bạn cũng sẽ sử dụng một cách khác để ngăn chặn các luồng công nhân bằng cách sử dụng một nguyên thủy khác với Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5,

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

51.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

51. Đối tượng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

53 cho phép một luồng báo hiệu

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

54 trong khi nhiều luồng khác có thể chờ đợi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

54 xảy ra. Việc sử dụng chính trong mã này là các luồng đang chờ sự kiện không nhất thiết phải dừng những gì họ đang làm, họ chỉ có thể kiểm tra trạng thái của

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

51 mỗi lần.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

57 nó:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

6

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)

54 trên dòng 8, vượt qua

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

54 dưới dạng tham số trên các dòng 10 và 11, và phần cuối cùng trên các dòng 13 đến 15, ngủ trong một giây, đăng nhập một tin nhắn, sau đó gọi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

57 về sự kiện.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 cũng không phải thay đổi quá nhiều:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

7

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

66 vào

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đã phải thay đổi thêm một chút:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

8

Mặc dù bạn phải lấy mã liên quan đến giá trị

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

66, bạn đã phải thực hiện một điều kiện

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

66 phức tạp hơn một chút. Nó không chỉ lặp lại cho đến khi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

54 được đặt, mà còn cần phải tiếp tục lặp cho đến khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63 được làm trống.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 thoát ra trong khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63 có tin nhắn trong đó, có hai điều xấu có thể xảy ra. Đầu tiên là bạn mất những tin nhắn cuối cùng đó, nhưng điều nghiêm trọng hơn là

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 có thể bị bắt khi cố gắng thêm một tin nhắn vào hàng đợi đầy đủ và không bao giờ quay lại.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

54 được kích hoạt sau khi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 đã kiểm tra điều kiện

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

74 nhưng trước khi nó gọi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

75.

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 hoàn toàn đầy đủ.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 sau đó sẽ gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62 sẽ đợi cho đến khi có không gian trên hàng đợi cho tin nhắn mới.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 đã thoát ra, vì vậy điều này sẽ không xảy ra và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 sẽ không thoát ra.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 sẽ trông quen thuộc.

Tuy nhiên,

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 đã thay đổi đáng kể:

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

9

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 là một lớp con của

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

83.

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42 có tham số tùy chọn khi khởi tạo để chỉ định kích thước tối đa của hàng đợi.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

85, nó sẽ giới hạn hàng đợi ở số lượng phần tử đó, khiến

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

86 chặn cho đến khi có ít hơn các phần tử

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

85. Nếu bạn không chỉ định

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

85, thì hàng đợi sẽ phát triển đến giới hạn bộ nhớ máy tính của bạn.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

93 và

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

62 nhỏ hơn nhiều. Về cơ bản, chúng bao bọc

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

91 và

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

86 trên

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42. Bạn có thể tự hỏi nơi tất cả các mã khóa ngăn chặn các luồng gây ra các điều kiện chủng tộc đã đi.

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)

42 thường được sử dụng trong môi trường đa luồng và kết hợp tất cả các mã khóa đó bên trong chính

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42.

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42 là an toàn cho luồng.

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

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

0

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ị xảy ra. Ngay trên đỉnh, bạn có thể thấy

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 phải tạo năm tin nhắn và đặt bốn trong số chúng vào hàng đợi. Nó đã được trao đổi bởi hệ điều hành trước khi nó có thể đặt cái thứ năm.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 sau đó chạy và rút tin nhắn đầu tiên. Nó đã in ra thông điệp đó cũng như hàng đợi sâu như thế nào vào thời điểm đó:

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

1

Đây là cách bạn biết rằng tin nhắn thứ năm đã không đưa nó vào

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63. Hàng đợi giảm xuống kích thước ba sau khi một tin nhắn được xóa. Bạn cũng biết rằng

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

45 có thể chứa mười tin nhắn, vì vậy chuỗi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 đã không bị chặn bởi

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

45. Nó đã được trao đổi bởi hệ điều hành.

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)

54 khiến

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 thoát ra ngay lập tức.

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 vẫn có một loạt các công việc làm, vì vậy nó tiếp tục chạy cho đến khi nó đã làm sạch

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

63.

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 đến

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting", name)
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

2 trong

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

59 hoặc

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

64 để mô phỏng thời gian truy cập mạng hoặc đĩa dài hơn tương ứng. Ngay cả những thay đổi nhỏ đối với các yếu tố này của chương trình sẽ tạo ra sự khác biệt lớn trong kết quả của bạn.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

53 thực sự không cần thiết cho vấn đề này. Khi bạn lấy đi việc khai thác, nó sẽ trở thành

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

83.

Ở đây, những gì mã cuối cùng trông giống như bằng cách sử dụng trực tiếp

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

83:

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

2

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

x = threading.Thread(target=thread_function, args=(1,))
x.start()

98 và

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

42 là các lớp tiện dụng để giải quyết các vấn đề đồng thời, nhưng có những lớp khác được cung cấp bởi thư viện tiêu chuẩn. Trước khi bạn kết thúc hướng dẫn này, hãy để một cuộc khảo sát nhanh về một số trong số họ.

Đối tượng luồng

Có một vài nguyên thủy được cung cấp bởi mô -đun Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5. Mặc dù bạn đã không cần những điều này cho các ví dụ ở trên, nhưng chúng có thể có ích trong các trường hợp sử dụng khác nhau, vì vậy, thật tốt khi làm quen với chúng.

Semaphore

Đối tượng Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5 đầu tiên nhìn vào là

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

17. A

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

18 là một bộ đếm với một vài thuộc tính đặc biệt. Điều đầu tiên là việc đếm là nguyên tử. Điều này có nghĩa là có một đảm bảo rằng hệ điều hành sẽ không trao đổi luồng ở giữa tăng hoặc giảm bộ đếm.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 và giảm khi bạn gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07.

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

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

07 khi bộ đếm bằng không, luồng đó sẽ chặn cho đến khi một luồng khác gọi

$ ./single_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done
Thread 1: finishing

08 và tăng bộ đếm lên một.

Semaphores thường được sử dụng để bảo vệ một tài nguyên có công suất 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ờ

Một

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

23 là một cách để lên lịch cho một chức năng được gọi sau một khoảng thời gian nhất định đã trôi qua. Bạn tạo một

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 bằng cách chuyển trong một số giây để chờ đợi và một chức năng để gọi:

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

3

Bạn bắt đầu

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 bằng cách gọi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

4. Hàm sẽ được gọi trên một chủ đề mới tại một số điểm sau thời gian được chỉ định, nhưng lưu ý rằng không có lời hứa rằng nó sẽ được gọi chính xác tại thời điểm bạn muốn.

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

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 mà bạn đã bắt đầu, bạn có thể hủy nó bằng cách gọi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

28. Gọi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

28 sau khi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 đã kích hoạt không làm gì và không tạo ra một ngoại lệ.

Một

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 có thể được sử dụng để nhắc người dùng hành động sau một khoảng thời gian cụ thể. Nếu người dùng thực hiện hành động trước khi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

24 hết hạn,

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

28 có thể được gọi.

Rào chắn

Một

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

34 có thể được sử dụng để giữ một số lượng cố định các luồng đồng bộ. Khi tạo

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

35, người gọi phải chỉ định số lượng chủ đề sẽ được đồng bộ hóa trên nó. Mỗi luồng gọi

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

36 trên

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

35. Tất cả chúng sẽ vẫn bị chặn cho đến khi số lượng luồng được chỉ định đang chờ, và sau đó tất cả được phát hành cùng một lúc.

Hãy nhớ rằng các chủ đề được lên lịch bởi hệ điều hành, mặc dù tất cả các luồng được phát hành đồng thời, chúng sẽ được lên kế hoạch để chạy một lần.

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

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

35 là cho phép một nhóm các luồng tự khởi tạo. Có các luồng chờ trên

$ ./daemon_thread.py
Main    : before creating thread
Main    : before running thread
Thread 1: starting
Main    : wait for the thread to finish
Main    : all done

35 sau khi chúng được khởi tạo sẽ đảm bảo rằng không có luồng nào bắt đầu chạy trước khi tất cả các luồng được hoàn thành với khởi tạo của chúng.

Kết luận: Chủ đề trong Python

Bây giờ bạn đã thấy nhiều về những gì Python

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

5 cung cấp và một số ví dụ về cách xây dựng các chương trình có luồng và các vấn đề họ giải quyết. Bạn cũng đã thấy một vài trường hợp về các vấn đề phát sinh khi viết và gỡ lỗi các chương trình có chủ đề.

Nếu bạn muốn khám phá các tùy chọn khác cho sự đồng thời trong Python, hãy kiểm tra tăng tốc chương trình Python của bạn với sự đồng thời.

Nếu bạn quan tâm đến việc thực hiện một lần lặn sâu trên mô -đun

x = threading.Thread(target=thread_function, args=(1,), daemon=True)

7, hãy đọc Async IO trong Python: một hướng dẫn hoàn chỉnh.

Dù bạn làm gì, bây giờ bạn có thông tin và sự tự tin mà bạn cần viết các chương trình bằng cách sử dụng chuỗi Python!

Đặc biệt cảm ơn độc giả JL Diaz vì đã giúp dọn dẹp phần giới thiệu.

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để làm sâu sắc thêm sự hiểu biết của bạn: Xây dựng bằng Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Threading in Python

Python có chủ đề thật không?

Python không hỗ trợ đa luồng vì Python trên trình thông dịch Cpython không hỗ trợ thực thi đa lõi thực sự thông qua đa luồng.Tuy nhiên, Python có một thư viện luồng.Gil không ngăn chặn luồng.Python does have a threading library. The GIL does not prevent threading.

Có phải chủ đề python có chủ đề hệ điều hành không?

Các chủ đề Python được triển khai bằng cách sử dụng các luồng HĐH trong tất cả các triển khai mà tôi biết (C Python, Pypy và Jython).Đối với mỗi luồng python, có một luồng hệ điều hành bên dưới. in all implementations I know (C Python, PyPy and Jython). For each Python thread, there is an underlying OS thread.

Là chủ đề python

Python không phải là do tự chủ của nó an toàn.Nhưng có những động thái để thay đổi điều này: Nogil, v.v. Loại bỏ Gil không tạo ra các chức năng an toàn.. But there are moves to change this: NoGil, etc. Removing the GIL does not make functions thread-safe.

Có phải chủ đề Python còn sống?

Phương thức is_alive () là một phương thức sẵn có của lớp luồng của mô -đun luồng trong Python.Nó sử dụng một đối tượng luồng và kiểm tra xem chủ đề đó có còn sống hay không, tức là nó vẫn đang chạy hay không.Phương thức này trả về đúng trước khi chạy () bắt đầu cho đến khi phương thức chạy () được thực thi.Thông số):. It uses a Thread object, and checks whether that thread is alive or not, ie, it is still running or not. This method returns True before the run() starts until just after the run() method is executed. Parameter(s):

programming python Daemon thread Python threading.thread python example Stop thread Python threading.event python