Trong Khoa học máy tính, một luồng được định nghĩa là đơn vị thực thi nhỏ nhất với một bộ hướng dẫn độc lập. Phân luồng là một trong những nguyên tắc cơ bản của lập trình python. Phân luồng trong Python hoặc các ngôn ngữ lập trình khác cho phép người dùng chạy các phần khác nhau của chương trình theo cách đồng thời và làm cho việc thiết kế chương trình trở nên đơn giản hơn. Ngoài ra, để biết thêm về sys. đối số dòng lệnh argv, nhấp vào đây. Show
Trong quá trình phân luồng, các bộ xử lý khác nhau chạy trên một chương trình và mỗi bộ xử lý thực hiện đồng thời một tác vụ độc lập. Tuy nhiên, nếu bạn muốn thực hiện đa xử lý, thì bạn cần thực thi mã của mình bằng một ngôn ngữ khác hoặc sử dụng mô-đun đa xử lý. Trước khi tiếp tục đọc bài viết này, hãy xem Self in Python Trong quá trình triển khai CPython của Python, các tương tác được thực hiện với Khóa phiên dịch toàn cầu (GIL), khóa này luôn giới hạn một chuỗi Python chạy tại một thời điểm. Trong phân luồng, các ứng cử viên tốt được coi là những người dành nhiều thời gian chờ đợi các sự kiện bên ngoài. Tất cả đều đúng trong trường hợp mã được viết bằng Python. Tuy nhiên, trong trường hợp phân luồng trong C không phải Python, chúng có khả năng giải phóng GIL và chạy đồng thời. Hiểu rõ hơn về sự khác biệt trong phân luồng giữa các ngôn ngữ lập trình khác nhau với các lớp python nâng cao của chúng tôi Xây dựng chương trình của bạn để sử dụng phân luồng sẽ giúp thiết kế rõ ràng hơn và dễ suy luận hơn. Hãy để chúng tôi xem cách bắt đầu một Python phân luồng. Làm cách nào để bắt đầu phân luồng trong Python?Thư viện chuẩn Python chứa một mô-đun có tên phân luồng, bao gồm tất cả những điều cơ bản cần thiết để hiểu rõ hơn về quy trình phân luồng. Với mô-đun này, bạn có thể dễ dàng đóng gói các luồng và cung cấp giao diện rõ ràng để làm việc với chúng. Nếu muốn bắt đầu một chuỗi, trước tiên, bạn cần tạo một phiên bản Chủ đề rồi triển khai. bắt đầu(). import logging
import threading
import time
def thread_func(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")
logging.info("Main : before creating thread...")
t = threading.Thread(target=thread_function,args=(1,))
logging.info("Main : before running thread...")
t.start()
logging.info("Main : wait for the thread to finish...")
# t.join()
logging.info("Main : all done...")Có thể quan sát thấy rằng phần chính chịu trách nhiệm tạo và bắt đầu chuỗi. t = threading.Thread(target=thread_function, args=(1,)) t.start() Khi một Chủ đề được tạo, một hàm và danh sách các đối số của hàm đó được truyền. Trong ví dụ trên, thread_function() đang được chạy và 1 được truyền dưới dạng đối số. Tuy nhiên, chức năng này chỉ ghi nhật ký tin nhắn với thời gian. sleep() ở giữa chúng Đầu ra của mã ở trên sẽ được hiển thị dưới 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... Chủ đề chỉ kết thúc sau phần Chính của mã chủ đề daemonVề mặt khoa học máy tính, daemon là một chương trình máy tính chạy như một tiến trình nền. Về cơ bản, nó là một chuỗi chạy trong nền mà không cần lo lắng về việc tắt nó. Một luồng daemon sẽ tắt ngay lập tức khi chương trình kết thúc. Tuy nhiên, nếu một chương trình đang chạy các luồng không phải Daemon, thì chương trình sẽ đợi các luồng đó hoàn thành trước khi kết thúc. Trong đoạn mã ví dụ ở trên, bạn có thể nhận thấy rằng có một khoảng dừng khoảng 2 giây sau khi chức năng chính in thông báo xong tất cả và trước khi chuỗi kết thúc. Điều này là do Python đợi chuỗi không phải daemon hoàn thành. xâu chuỗi. shutdown() đi qua tất cả các luồng và cuộc gọi đang chạy. tham gia vào mọi chủ đề không phải daemonic. Bạn có thể hiểu rõ hơn nếu xem nguồn Python threading. Hãy để chúng tôi sử dụng ví dụ mà chúng tôi đã làm trước đây với một luồng daemon bằng cách thêm cờ daemon=True t = luồng. Chủ đề (mục tiêu = thread_function, args = (1,), daemon = True) Bây giờ nếu bạn chạy chương trình của mình, đầu ra sẽ như sau. $ ./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 cơ bản ở đây là dòng đầu ra cuối cùng bị thiếu. Điều này là do khi chức năng chính chạy đến cuối mã, daemon đã bị giết Đa luồng trong PythonQuá trình thực thi nhiều luồng theo cách song song được gọi là đa luồng. Nó nâng cao hiệu suất của chương trình và Python đa luồng khá dễ học Hãy để chúng tôi bắt đầu tìm hiểu đa luồng bằng ví dụ chúng tôi đã sử dụng trước đó import logging
import threading
import time
def thread_func(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")
multiple_threads = list()
for index in range(3):
logging.info("Main : create and start thread %d...",index)
t = threading.Thread(target=thread_function,args=(index,))
threads.append(x)
t.start()
for index, thread in enumerate(multiple_threads):
logging.info("Main : before joining thread %d...",index)
thread.join()
logging.info("Main : thread %d done...",index)Mã này sẽ hoạt động giống như trong quá trình bắt đầu một luồng. Đầu tiên, chúng ta cần tạo một đối tượng Thread và sau đó gọi phương thức. bắt đầu() đối tượng. Sau đó, chương trình giữ một danh sách các đối tượng Thread. Sau đó, nó đợi họ sử dụng. tham gia(). Nếu chúng tôi chạy mã này nhiều lần, đầu ra sẽ như dướ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.. Các luồng được sắp xếp theo thứ tự ngược lại trong ví dụ này. Điều này là do đa luồng tạo ra các thứ tự khác nhau. chủ đề x. thông báo kết thúc thông báo khi mỗi chủ đề được thực hiện. Thứ tự luồng được xác định bởi hệ điều hành, vì vậy điều cần thiết là phải biết thiết kế thuật toán sử dụng quy trình luồng. Trình thực thi ThreadPoolSử dụng ThreadpoolExecutor là cách dễ dàng hơn để bắt đầu một nhóm luồng. Nó được chứa trong Thư viện chuẩn Python đồng thời. tương lai. Bạn có thể tạo nó dưới dạng trình quản lý bối cảnh bằng sự trợ giúp của câu lệnh with. Nó sẽ giúp quản lý và phá hủy hồ bơi. Ví dụ minh họa ThreadpoolExecutor (chỉ phần chính). import concurrent.futures
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) asexecutor:
executor.map(thread_function,range(3))Đoạn mã trên tạo một ThreadpoolExecutor và thông báo có bao nhiêu worker thread nó cần trong pool, và sau đó. map() được sử dụng để duyệt qua một danh sách các thứ. Khi với khối kết thúc,. tham gia () được sử dụng trên mỗi chủ đề trong nhóm. Bạn nên sử dụng ThreadpoolExecutor bất cứ khi nào có thể để bạn không bao giờ quên. tham gia () các chủ đề Đầu ra của mã sẽ như sau $ ./executor.py Thread 0: starting... Thread 1: starting... Thread 2: starting... Thread 1: finishing... Thread 0: finishing... Thread 2: finishing… Điều kiện cuộc đuaKhi nhiều luồng cố gắng truy cập vào một phần dữ liệu hoặc tài nguyên được chia sẻ, điều kiện tương tranh sẽ xảy ra. Điều kiện cuộc đua tạo ra kết quả khiến người dùng khó hiểu và hiếm khi xảy ra và rất khó gỡ lỗi Chúng ta hãy cố gắng hiểu một điều kiện chủng tộc bằng cách sử dụng một lớp có cơ sở dữ liệu sai ________số 8_______Lớp FalseDatabase giữ giá trị dữ liệu được chia sẻ mà trên đó điều kiện tương tranh sẽ xảy ra. Hàm race chỉ đơn giản là khởi tạo. giá trị bằng không. Công việc của. update() là phân tích cơ sở dữ liệu, thực hiện một số tính toán, sau đó ghi lại một giá trị vào cơ sở dữ liệu. Tuy nhiên, đọc từ cơ sở dữ liệu có nghĩa là chỉ sao chép. giá trị cho biến cục bộ. Tính toán có nghĩa là thêm một giá trị và sau đó. sleep() một chút, sau đó giá trị được ghi lại bằng cách sao chép giá trị cục bộ trở lại. giá trị() Phần chính của FalseDatabase if __name__ == "__main__":
format = "%(asctime)s: %(message)s"
logging.basicConfig(format=format, level=logging.INFO,
datefmt="%H:%M:%S")
dtb = FalseDatabase()
logging.info("Testing update. Starting value is %d...",dtb.value)
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
for index in range(2):
executor.submit(dtb.update,index)
logging.info("Testing update. Ending value is %d...", dtb.value)Các chương trình tạo một ThreadPoolExecutor có hai luồng và lệnh gọi. submit() rồi chạy cơ sở dữ liệu. cập nhật() submit() chứa hai đối số. cả đối số vị trí và đối số được đặt tên đều được chuyển đến hàm đang chạy trong luồng. đệ trình (hàm, *args, **kwargs) Đầu ra sẽ như sau. t = threading.Thread(target=thread_function, args=(1,)) t.start()0 một chủ đềTrong phần này, chúng ta sẽ thảo luận về cách các luồng hoạt động theo cách đơn giản hóa. Khi ThreadPoolExecutor được thông báo để chạy từng luồng, về cơ bản, chúng tôi sẽ cho nó biết chức năng nào sẽ chạy và thông số nào sẽ được truyền. người thừa hành. gửi (cơ sở dữ liệu. cập nhật, lập chỉ mục). Điều này sẽ cho phép mỗi luồng trong nhóm gọi người thực thi. gửi (chỉ mục). Cơ sở dữ liệu là tham chiếu đến đối tượng FalseDatabase được tạo trong hàm main Mỗi luồng sẽ có một tham chiếu đến cơ sở dữ liệu và cũng có một giá trị chỉ mục duy nhất sẽ làm cho báo cáo nhật ký có thể đọc được. Chuỗi chứa phiên bản riêng của tất cả dữ liệu cục bộ cho hàm. Đây được gọi là local_copy trong trường hợp. cập nhật(). Đây là một lợi thế cho phép tất cả các biến cục bộ của hàm an toàn theo luồng hai chủ đềNếu chúng tôi xem xét lại điều kiện cuộc đua, hai luồng sẽ chạy đồng thời. Mỗi người sẽ trỏ đến cùng một cơ sở dữ liệu đối tượng và sẽ có phiên bản local_copy của riêng họ. Đối tượng cơ sở dữ liệu sẽ là nguyên nhân gây ra sự cố. Chương trình sẽ bắt đầu với Thread 1 đang chạy. update() và sau đó luồng sẽ gọi thời gian. sleep() và cho phép các luồng khác thế chỗ và bắt đầu chạy. Bây giờ Chủ đề 2 thực hiện tất cả các thao tác giống như Chủ đề 1. Nó cũng sao chép cơ sở dữ liệu. giá trị vào local_copy nhưng cơ sở dữ liệu. giá trị không được cập nhật. Bây giờ khi Chủ đề 2 kết thúc, cơ sở dữ liệu được chia sẻ. giá trị vẫn chứa số không và cả hai phiên bản local_copy đều có giá trị một. Cuối cùng, Chủ đề 1 lại thức dậy và nó kết thúc bằng cách lưu local_copy của nó, điều này tạo cơ hội cho Chủ đề 2 chạy. Mặt khác, Chủ đề 2 không biết về Chủ đề 1 và cơ sở dữ liệu được cập nhật. giá trị. Chủ đề 2 sau đó cũng lưu trữ phiên bản local_copy của nó vào cơ sở dữ liệu. giá trị. Điều kiện chủng tộc xảy ra ở đây theo nghĩa là Chủ đề 1 và Chủ đề 2 có quyền truy cập xen kẽ vào một đối tượng được chia sẻ duy nhất và chúng ghi đè lên kết quả của nhau. Điều kiện tranh đua cũng có thể xảy ra khi một luồng giải phóng bộ nhớ hoặc đóng một tệp xử lý trước khi luồng khác làm việc. Đồng bộ hóa cơ bản trong luồngBạn có thể giải quyết các điều kiện cuộc đua với sự trợ giúp của Khóa. Khóa là một đối tượng hoạt động giống như thẻ hội trường, mỗi lần chỉ cho phép một luồng vào phần đọc-sửa-ghi của mã. Nếu bất kỳ chủ đề nào khác muốn vào cùng một lúc, chủ đề đó phải đợi cho đến khi chủ sở hữu hiện tại của Khóa từ bỏ nó. Các chức năng cơ bản là. thu được() và. phóng thích(). Một chủ đề sẽ gọi my_lock. có được () để lấy Khóa. Tuy nhiên, chuỗi này sẽ phải đợi nếu Khóa được giữ bởi một chuỗi khác cho đến khi chuỗi này giải phóng. Python khóa cũng hoạt động như một trình quản lý bối cảnh và có thể được sử dụng trong một câu lệnh with và sẽ được giải phóng tự động khi thoát khỏi khối with. Hãy lấy lớp FalseDatabase trước đó và thêm Khóa vào lớp đó t = threading.Thread(target=thread_function, args=(1,)) t.start()1 _lock là một phần của luồng. Lock() đối tượng và được khởi tạo ở trạng thái không khóa và sau đó được giải phóng với sự trợ giúp của câu lệnh with. Đầu ra của mã ở trên với ghi nhật ký được đặt ở mức cảnh báo sẽ như sau. t = threading.Thread(target=thread_function, args=(1,)) t.start()2 Đầu ra của mã với ghi nhật ký đầy đủ bằng cách đặt mức thành GỠ LỖI t = threading.Thread(target=thread_function, args=(1,)) t.start()3 Khóa cung cấp loại trừ lẫn nhau giữa các luồng Vấn đề xâu chuỗi Producer-ConsumerTrong Khoa học Máy tính, Vấn đề Phân luồng Nhà sản xuất-Người tiêu dùng là một ví dụ cổ điển về vấn đề đồng bộ hóa đa quy trình. Hãy xem xét một chương trình phải đọc tin nhắn và ghi chúng vào đĩa. Nó sẽ lắng nghe và chấp nhận tin nhắn khi chúng xuất hiện theo đợt và không đều đặn. Phần này của chương trình được gọi là nhà sản xuất. Mặt khác, bạn cần viết tin nhắn vào cơ sở dữ liệu sau khi bạn có nó. Truy cập cơ sở dữ liệu này chậm do có nhiều tin nhắn đến. Phần này của chương trình được gọi là người tiêu dùng. Một đường dẫn phải được tạo giữa nhà sản xuất và người tiêu dùng sẽ đóng vai trò là bộ phận thay đổi khi bạn thu thập thêm kiến thức về các đối tượng đồng bộ hóa khác nhau. Sử dụng KhóaThiết kế cơ bản là một chuỗi sản xuất sẽ đọc từ mạng giả và đưa thông báo vào đường ống dẫn. t = threading.Thread(target=thread_function, args=(1,)) t.start()4 Nhà sản xuất lấy một số ngẫu nhiên từ 1 đến 100 và gọi. set_message() trên quy trình bán hàng để gửi cho người tiêu dùng. t = threading.Thread(target=thread_function, args=(1,)) t.start()5 Người tiêu dùng đọc thông báo từ quy trình bán hàng và hiển thị cơ sở dữ liệu sai Phần chính của phần này như sau t = threading.Thread(target=thread_function, args=(1,)) t.start()6 Bây giờ chúng ta hãy xem mã của Pipeline sẽ chuyển thông điệp từ nhà sản xuất đến người tiêu dùng. t = threading.Thread(target=thread_function, args=(1,)) t.start()7 Các thành viên của Pipeline là.
Hàm pipe_message khởi tạo ba thành viên và sau đó gọi. thu được () trên. người tiêu dùng_lock. Bây giờ nhà sản xuất có quyền thêm thông báo và người tiêu dùng phải đợi cho đến khi thông báo xuất hiện. get_msg cuộc gọi. có được trên Consumer_lock và sau đó người tiêu dùng sao chép giá trị trong. tin nhắn và sau đó gọi. phát hành() trên. nhà sản xuất_lock. Sau khi khóa được giải phóng, nhà sản xuất có thể chèn thông báo vào đường ống. Bây giờ nhà sản xuất sẽ gọi. set_msg(), và nó sẽ lấy. producer_lock và đặt. msg, sau đó khóa được giải phóng và người tiêu dùng có thể đọc giá trị. Đầu ra của mã với nhật ký được đặt thành CẢNH BÁO. t = threading.Thread(target=thread_function, args=(1,)) t.start()8 Các đối tượng trong ThreadingPython bao gồm một vài mô-đun luồng, có thể hữu ích trong các trường hợp khác nhau. Một số trong số này được thảo luận dưới đây. 1. đèn hiệuMột semaphore là một mô-đun truy cập với một vài thuộc tính duy nhất. Thuộc tính đầu tiên là bộ đếm của nó là nguyên tử, điều đó có nghĩa là hệ điều hành sẽ không hoán đổi luồng trong khi tăng hoặc giảm bộ đếm. Bộ đếm bên trong tăng khi. release() được gọi và giảm dần khi. thu được() được gọi là. Thuộc tính khác là nếu một luồng gọi. got() trong khi bộ đếm bằng 0, thì luồng sẽ bị chặn cho đến khi luồng khác gọi. phóng thích(). Công việc chính của semaphores là bảo vệ tài nguyên có dung lượng hạn chế. Nó được sử dụng trong trường hợp bạn có một nhóm kết nối và bạn muốn giới hạn kích thước của nhóm ở một số cụ thể. 2. hẹn giờMô-đun Bộ hẹn giờ được sử dụng để lên lịch một chức năng sẽ được gọi sau một khoảng thời gian nhất định đã trôi qua. Bạn cần vượt qua một số giây để chờ đợi và một chức năng để gọi để tạo Bộ hẹn giờ t = luồng. Hẹn giờ(20. 0,my_timer_function) Bộ đếm thời gian được bắt đầu bằng cách gọi. start và bạn có thể dừng nó bằng cách gọi. sự hủy bỏ(). Bộ hẹn giờ nhắc nhở hành động sau một khoảng thời gian cụ thể. 3. Điều kiệnĐối tượng điều kiện được sử dụng để đồng bộ hóa các chủ đề. Một biến điều kiện có thể được liên kết với một tài nguyên được chia sẻ vì nó luôn được kết hợp với một số khóa. Một khóa có thể được chỉ định hoặc một khóa sẽ được tạo tự động. Chuyển một vào rất hữu ích khi nhiều biến điều kiện phải chia sẻ cùng một khóa. Chúng tôi không cần theo dõi khóa riêng lẻ vì nó là một phần của đối tượng điều kiện. Do đó, các luồng có thể sử dụng đối tượng điều kiện để chờ tài nguyên được cập nhật. 4. Biến cốĐối tượng lớp Sự kiện cung cấp một cơ chế cơ bản để giao tiếp luồng trong đó một luồng báo hiệu một sự kiện và các luồng khác chờ đợi nó. Vì vậy, khi luồng được thiết kế để tạo tín hiệu sẽ tạo ra nó, luồng chờ được kích hoạt. Đối tượng sự kiện sử dụng một cờ nội bộ được gọi là cờ sự kiện, cờ này có thể được đặt thành true bằng hàm set() và đặt lại thành false bằng phương thức clear(). Phương thức wait() đóng băng một luồng cho đến khi bất kỳ luồng nào khác đặt cờ sự kiện mà nó đang chờ thành true. 5. Rào chắnĐối tượng rào cản có thể được sử dụng để đồng bộ hóa một số luồng đã đặt. Người gọi phải cho biết có bao nhiêu luồng sẽ đồng bộ hóa trên Rào chắn khi được tạo. Mỗi luồng thực hiện cuộc gọi, chờ đợi () trên Rào chắn và tất cả chúng sẽ bị chặn cho đến khi số lượng luồng đã nêu đang chờ, tại thời điểm đó, tất cả chúng sẽ được giải phóng đồng thời. Hệ điều hành lên lịch cho các luồng, vì vậy ngay cả khi tất cả các luồng được giải phóng đồng thời, chúng sẽ chỉ chạy một luồng tại một thời điểm. Một Rào cản có thể được sử dụng để cho phép một nhóm chủ đề tự khởi tạo. Để các luồng chờ trên Rào chắn sau khi chúng được khởi tạo đảm bảo rằng không có luồng nào chạy trước khi các luồng khác hoàn thành quá trình khởi tạo của chúng. 6. Giới HạnSemaphoreMột semaphore giới hạn giống hệt với một đối tượng semaphore, ngoại trừ giới hạn trên của semaphore không thể tăng lên. Khi các semaphores được xây dựng, chúng được cung cấp một giá trị đếm bắt đầu. Mỗi lệnh gọi acrec() làm giảm bộ đếm nội bộ, trong khi mỗi lệnh gọi release() tăng bộ đếm. Chúng ta có thể gọi phương thức release() nhiều lần hơn phương thức thu được(), cho phép bộ đếm bên trong vượt quá số lượng ban đầu. Tóm lượcTrong bài viết này, chúng tôi đã đề cập đến hầu hết các chủ đề liên quan đến luồng trong Python. Chúng tôi đã thảo luận sau đây
Chúng tôi hy vọng bạn hiện đã biết rõ về phân luồng Python và cách xây dựng các chương trình phân luồng cũng như các vấn đề mà chúng tiếp cận để giải quyết. Bạn cũng đã thu được kiến thức về các vấn đề phát sinh khi viết và gỡ lỗi các loại chương trình luồng khác nhau. Để có thêm kiến thức về các mẹo và thủ thuật Python, hãy xem hướng dẫn Python của chúng tôi và hiểu rõ về mã hóa trong Python bằng cách tham gia khóa học Kiến thức cơ bản về lập trình Python. Đó là những phương pháp trong gói luồng?run() - Phương thức run() là điểm bắt đầu cho một luồng start() − Phương thức start() bắt đầu một luồng bằng cách gọi phương thức run tham gia ([thời gian]) - Tham gia () chờ các luồng kết thúc isAlive() − Phương thức isAlive() kiểm tra xem một luồng có còn đang thực thi hay không Các loại chủ đề trong Python là gì?Có hai loại chủ đề riêng biệt. đó là. Chủ đề cấp người dùng. Đây là những thứ chúng ta có thể tích cực chơi với mã của mình, v.v. Luồng cấp hạt nhân. Đây là những luồng cấp rất thấp hoạt động thay mặt cho hệ điều hành .
Gói luồng trong Python là gì?Phân luồng trong python được dùng để chạy nhiều luồng (tác vụ, lệnh gọi hàm) cùng một lúc . Lưu ý rằng điều này không có nghĩa là chúng được thực thi trên các CPU khác nhau. Các luồng Python sẽ KHÔNG làm cho chương trình của bạn nhanh hơn nếu nó đã sử dụng 100% thời gian CPU. Trong trường hợp đó, bạn có thể muốn xem xét lập trình song song.
Phương pháp nào được sử dụng để xác định một luồng trong Python?getName() − Phương thức getName() trả về tên của một luồng. setName() − Phương thức setName() đặt tên của một luồng. |
