programming python

Python đợi cho đến khi biến là đúng

Mô-đun này xây dựng các giao diện phân luồng cấp cao hơn trên mô-đun 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
3 cấp thấp hơn

Sửa đổi ở phiên bản 3. 7. Ce module était auparavant optionnel, il est maintenant toujours disponible.

Voir aussi

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
4 cung cấp một giao diện cấp cao hơn để đẩy các tác vụ tới một luồng nền mà không chặn thực thi luồng đang gọi, trong khi vẫn có thể truy xuất kết quả của chúng khi cần

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
5 cung cấp giao diện an toàn cho luồng để trao đổi dữ liệu giữa các luồng đang chạy

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
6 cung cấp một cách tiếp cận khác để đạt được sự đồng thời ở cấp độ tác vụ mà không yêu cầu sử dụng nhiều luồng hệ điều hành

Ghi chú

Trong Python 2. x, mô-đun này chứa tên 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
7 cho một số phương thức và chức năng. Chúng không được dùng nữa kể từ Python 3. 10, nhưng chúng vẫn được hỗ trợ để tương thích với Python 2. 5 và thấp hơn

Particularité de l'implémentation CPython. Trong CPython, do Khóa phiên dịch toàn cầu , nên chỉ một luồng có thể thực thi mã Python cùng một lúc [mặc dù một số thư viện định hướng hiệu suất nhất định có thể vượt qua giới hạn này]. Nếu bạn muốn ứng dụng của mình tận dụng tốt hơn tài nguyên tính toán của các máy đa lõi, bạn nên sử dụng 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
8 hoặc 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
9. Tuy nhiên, phân luồng vẫn là mô hình phù hợp nếu bạn muốn chạy đồng thời nhiều tác vụ liên kết I/O.

Tính khả dụng . không phải Emscripten, không phải WASI.

Mô-đun này không hoạt động hoặc không khả dụng trên nền tảng WebAssembly 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
0 và 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
1. Xem Nền tảng WebAssugging để biết thêm thông tin.

Mô-đun xác định các chức năng hỗ trợ

phân luồng. active_count[]

Renvoie le nombre d'objets 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 actuellement vivants. Le compte renvoyé est égal à la longueur de la liste renvoyée par 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
3

Hàm 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
4 là bí danh không dùng nữa cho hàm này

phân luồng. current_thread[]

Renvoie l'objet 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 bảo lãnh, phóng viên au fil de contrôle de l'appelant. Si le fil de contrôle de l'appelant n'a pas été créé via le module 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2, un object thread factice aux fonctionnalités limitées est renvoyé

Hàm 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
7 là bí danh không dùng nữa cho hàm này

phân luồng. excepthook[args , /]

Gère les les Exceptions non-attrapées levées par 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
8

L'argument arg a les attributs suivants

  • exc_type. le type de l'Exception ;

  • ex_value. la valeur de l'Exception, peut être 

    # Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
    9 ;

  • exc_traceback. la đống d'appels pour cette ngoại lệ, peut être 

    # Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
    9 ;

  • chủ đề. le fil d'exécution ayant levé l'Exception, peut être 

    # Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
    9

Si exc_type est 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
92, l'Exception est ignorée im lặng. Toutes les autres sont affichées sur 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
93

Si cette fonction lève une une exception, 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
94 est appelée pour la gérer

La fonction 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
95 peut être surchargée afin de contrôler comment les les Exceptions non-attrapées levées par 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
8 sont gérées

Stocker exc_value en utilisant une fonction de rappel personnalisée peut créer un cycle de références. exc_value doit être nettoyée sự giải thích pour casser ce chu kỳ lorsque l'Exception n'est plus nécessaire

Stocker thread en utilisant une fonction de rappel personnalisée peut le ressusciter, si c'est un objet en cours de finalization. Évitez de stocker thread après la fin de la fonction de rappel, pour éviter de ressusciter des objets

Voir aussi

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
94 gère les Exceptions qui n'ont pas été attrapées

Mới nhất dans la phiên bản 3. 8

phân luồng. __ngoại trừhook__

Giữ giá trị ban đầu của 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
95. Nó được lưu để giá trị ban đầu có thể được khôi phục trong trường hợp chúng bị thay thế bằng các đối tượng bị hỏng hoặc thay thế

Mới nhất dans la phiên bản 3. 10

phân luồng. get_ident[]

Revoie l'« identifiant de fil » du fil d'exécution courant. C'est un entier non nul. Sa valeur n'a pas de signification directe ; . Les identificateurs de fils peuvent être recyclés lorsqu'un fil se termine et qu'un autre fil est créé

Mới nhất dans la phiên bản 3. 3

phân luồng. get_native_id[]

Renvoie l'identifiant natif complet assignment par le noyau du fil d'exécution actuel. C'est un entier non négatif. Sa valeur peut uniquement être utilisée pour ID ce fil d'exécution à l'échelle du système [jusqu'à ce que le fil d'exécution se termine, après quoi la valeur peut être recyclée par le système d'exploitation]

Trách nhiệm . Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX.

Mới nhất dans la phiên bản 3. 8

phân luồng. liệt kê[]

Trả về danh sách tất cả 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 đối tượng hiện đang hoạt động. Danh sách này bao gồm các luồng daemon và các đối tượng luồng giả được tạo bởi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70. Nó loại trừ các chủ đề đã kết thúc và các chủ đề chưa được bắt đầu. Tuy nhiên, luồng chính luôn là một phần của kết quả, ngay cả khi bị chấm dứt

phân luồng. main_thread[]

Renvoie l'objet fil d'exécution 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 hiệu trưởng. Dans des conditiones normales, le fil principal est le fil à partir duquel l'interpréteur Python a été lancé

Mới nhất dans la phiên bản 3. 4

phân luồng. settrace[chức năng]

Attache une fonction de traçage pour tous les fils d'exécution démarrés depuis le module 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2. La fonction func est passée à 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
73 pour chaque fil, avant que sa méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 soit appelée

phân luồng. gettrace[]

Nhận chức năng theo dõi như được thiết lập bởi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
75

Mới nhất dans la phiên bản 3. 10

phân luồng. setprofile[chức năng]

Attache une fonction de profilage pour tous les fils d'exécution démarrés depuis le module 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
76. La fonction func est passée à 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
77 pour chaque fil, avant que sa méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 soit appelée

phân luồng. lấy hồ sơ[]

Nhận chức năng hồ sơ như được thiết lập bởi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
79

Mới nhất dans la phiên bản 3. 10

phân luồng. stack_size[[kích thước]]

Renvoie la taille de la pill d'exécution utilisée lors de la création de nouveaux fils d'exécution. L'argument optionnel size spécifie la taille de pill à utiliser pour les fils créés ultérieurement, et doit être 0 [pour utiliser la taille de la plate-forme ou la valeur configurée par défaut] ou un entier positif supérieur ou égal à 32 768 [ . Si size n'est pas spécifié, 0 est utilisé. Si la Mod de la Taille de la Pile de Fils n'est pas Prize en Charge, une 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 est levée. Si la taille de đống spécifiée n'est pas valide, une 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
71 est levée et la taille de đống n'est pas modifiée. 32 Kio est actuellement la valeur minimume de taille de cọc giải thưởng en charge pour garantir un espace de cọc suffisant pour l'interpréteur lui-même. Lưu ý rằng các tấm-formes peuvent avoir des các hạn chế particulières sur les valeurs de taille de la đống, cho biết que l'exigence d'une taille de đống tối thiểu > 32 Phân bổ ki-ốt ou d'une en multiples de la taille de la mémoire

Tính khả dụng . Windows, pthread.

Nền tảng Unix có hỗ trợ chủ đề POSIX

Mô-đun xác định chính xác hệ số liên tục

phân luồng. TIMEOUT_MAX

La valeur maximale autorisée pour le paramètre timeout des fonctions bloquantes [

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
72, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
73, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74, v.v. ]. Specifier un délai d'attente supérieur à cette valeur lève une 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
75

Mới nhất dans la phiên bản 3. 2

Mô-đun xác định một số lớp nhất định, không phải là chi tiết trong các bộ phận của điện thoại

La concept de ce module est librement base sur le modèle des fils d'exécution de Java. Cependant, is où Java fait des verrous et des variable de condition le compportement de base de chaque object, ils sont des séparés en Python. Lớp Python 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 chịu trách nhiệm về việc sous-ensemble du compportement de la class Thread de Java ; . Les méthodes statiques de la classe Thread de Java, lorsqu'elles sont implémentées, phóng viên à des fonctions au niveau du module

Toutes les méthodes décrites ci-dessous sont exécutées de manière atomique

Données locales au fil d'exécution¶

Les données locales au fil d'exécution [dữ liệu cục bộ luồng] sont des données not les valeurs sont propres à chaque fil. Pour gérer les données locales au fil, il suffit de créer une instance de 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
77 [ou une sous-classe] et d'y stocker des données

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
5

Les valeurs dans l'instance sont différentes pour des thread différents

lớp phân luồng. cục bộ

Classe qui représente les données locales au fil d'exécution

Đổ cộng với các chi tiết và các ví dụ điển hình, voir la chaîne de documentation du module 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
78

Chủ đề đối tượng¶

La classe fil d'exécution 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 représente une activité qui est exécutée dans un fil d'exécution séparé. Il y a deux façons de specifier l'activité. en passant un objet appelable au constructeur, ou en ré-implémentant la méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 dans une sous-classe. Aucune autre méthode [à l'Exception du constructor] ne doit être remplacée dans une sous-classe. En d'autres termes, réimplémentez seulement les méthodes 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
91 et 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 de cette classe

Une fois qu'un objet fil d'exécution est créé, son activité doit être lancée en appelant la méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
93 du fil. Ceci invoque la méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 dans un fil d'exécution séparé

Une fois que l'activité du fil d'exécution est lancée, le fil est considéré comme « vivant ». Il cesse d'être vivant lorsque sa méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 se termine – soit normalement, soit en levant une exception non gérée. La méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
96 teste si le fil est vivant

D'autres fils d'exécution peuvent appeler la méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 d'un fil. Ceci bloque le fil appelant jusqu'à ce que le fil don't la méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 est appelée soit terminé

Un fil d'exécution a un nom. Le nom peut être passé au constructeur, et lu ou modifié via l'attribut 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
99

Si la méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 lève une exception, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
95 est appelée pour s'en occuper. Par défaut, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
95 bỏ qua sự im lặng 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
92

Un fil d'exécution peut être marqué comme « fil démon ». Un program Python se termine quand il ne reste plus que des fils quỷ. La valeur initiale est héritée du fil d'exécution qui l'a créé. Cette option peut être définie par la propriété 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
24 ou par l'argument daemon du Constructeur

Ghi chú

Những bộ phim hành quyết ma quỷ không phải là sự kết thúc đột ngột của chương trình Python. Leurs ressources [fichiers ouverts, giao dịch de base de données, v.v. ] peuvent ne pas être libérées sự sửa sai. Si vous voulez que vos fils s'arrêtent proprement, faites en sorte qu'ils ne soient pas démoniques et utilisez un mécanisme de signalisation approprié tel qu'un objet évènement 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
25

Il y a un objet "fil principal", nó tương ứng với au fil de control ban đầu dans le program Python. Ce n'est pas un fil ma quỷ

Có khả năng "đối tượng chuỗi giả" được tạo. Đây là các đối tượng luồng tương ứng với "luồng ngoài hành tinh", là luồng điều khiển bắt đầu bên ngoài mô-đun luồng, chẳng hạn như trực tiếp từ mã C. Các đối tượng luồng giả có chức năng hạn chế; . Chúng không bao giờ bị xóa, vì không thể phát hiện ra sự chấm dứt của các luồng ngoài hành tinh. joined. They are never deleted, since it is impossible to detect the termination of alien threads.

lớp phân luồng. Chủ đề[nhóm=Không có, target=None, name=None, args=[], kwargs={}, *, daemon=None]

Ce Constructeur doit toujours être appelé avec des arguments nommés. Les đối số sont

nhóm doit être 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 ;

target est l'objet appelable qui doit être invoqué par la méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74. La valeur par défaut est 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, ce qui signifie que rien n'est appelé

tên là tên chủ đề. Theo mặc định, một tên duy nhất được tạo ở dạng "Thread-N" trong đó N là một số thập phân nhỏ hoặc "Thread-N [đích]" trong đó "đích" là 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
80 nếu đối số đích được chỉ định

args là một danh sách hoặc bộ đối số cho lệnh gọi đích. Mặc định là 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
81

kwargs est un dictionnaire d'arguments nommés pour l'invocation de l'objet appelable. La valeur par défaut est 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
82

S'il ne vaut pas 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, daemon xác định rõ ràng si le fil d'exécution est démonique ou pas. S'il vaut 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 [par défaut], la valeur est héritée du fil courant

Si la sous-classe réimplémente le constructeur, elle doit s'assurer d'appeler le constructeur de la classe de base [

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
85] avant de faire autre đã chọn au fil d'exécution

Sửa đổi ở phiên bản 3. 10. Sử dụng tên mục tiêu nếu đối số tên bị bỏ qua.

Sửa đổi ở phiên bản 3. 3. Daemon đối số.

bắt đầu[]

Lance l'activité du fil d'exécution

Elle ne doit être appelée qu'une fois par objet de fil. Elle fait en sorte que la methode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 de l'objet soit invoquée dans un fil d'exécution

Cette méthode lève une 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 si elle est appelée plus d'une fois sur le même objet fil d'exécution

chạy[]

Méthode représentant l'activité du fil d'exécution

Vous pouvez remplacer cette méthode dans une sous-classe. La méthode standard 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 invoque l'objet appelable passé au Constructeur de l'objet en tant qu'argument target, le cas échéant, avec des đối số vị trí và các đối số nommés Tires tương ứng des đối số và kwargs

Sử dụng danh sách hoặc bộ dữ liệu làm đối số args được chuyển đến 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 có thể đạt được hiệu quả tương tự

Thí dụ

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1

tham gia[hết thời gian=Không có]

Tham dự que le fil d'exécution se termine. Ceci bloque le fil appelant jusqu'à ce que le fil don't la méthode 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 est appelée se termine – soit normalement, soit par une exception non gérée – ou jusqu'à ce que le délai optionnel timeout soit atteint

Lorsque l'argument timeout est présent et ne vaut pas 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, il doit être un nombre en virgule flottante spécifiant un délai pour l'opération en seconds [ou các phân số của giây]. Comme 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 renvoie toujours 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, vous devez appeler 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
96 après 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 pour déterminer si le délai a expiré – si le fil d'exécution est toujours vivant, c'est que l'appel à 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 a expiré

Lorsque l'argument timeout n'est pas présent ou vaut 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, l'opération se bloque jusqu'à ce que le fil d'exécution se termine

Một chủ đề có thể được tham gia nhiều lần

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 lève une 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 si une tentative est faite pour Attendre le fil d'exécution courant car cela conduirait à un interblocage [deadlock en anglais]. Tham dự qua 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
97 un fil d'exécution avant son lancement est aussi une erreur et, si vous tenez de le faire, lève la même exception

tên

Une chaîne de caractères utilisée à des fins d'identification seulement. Elle n'a pas de sémantique. Plusieurs fils d'exécution peuvent porter le même nom. Le nom initial est défini par le Constructeur

getName[]setName[]

API getter/setter không dùng nữa cho 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
99;

Obsolète depuis la phiên bản 3. 10

nhận dạng

« L'identificateur de fil d'execution » de ce fil ou 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 si le fil n'a pas été lancé. C'est un entier non nul. Voyez également la fonction 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
03. Les identificateurs de fils peuvent être recyclés lorsqu'un fil se termine et qu'un autre fil est créé. L'identifiant est disponible même après que le fil ait terminé

native_id

ID chủ đề [

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
04] của chủ đề này, như được chỉ định bởi hệ điều hành [nhân]. Đây là một số nguyên không âm hoặc 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 nếu chuỗi chưa được bắt đầu. Xem hàm 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
06. Giá trị này có thể được sử dụng để xác định duy nhất luồng cụ thể này trên toàn hệ thống [cho đến khi luồng kết thúc, sau đó hệ điều hành có thể tái chế giá trị này]

Ghi chú

Tout comme pour les Process IDs, les Thread IDs ne sont valides [garantis uniques sur le système] uniquement du démarrage du fil à sa fin

Tính khả dụng . Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX, DragonFlyBSD.

Mới nhất dans la phiên bản 3. 8

is_alive[]

Renvoie si le fil d'exécution est vivant ou pas

Cette méthode renvoie 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 depuis juste avant le démarrage de la méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74 et jusqu'à juste après la terminaison de la méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
74. La fonction 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
3 du module renvoie une liste de tous les fils d'exécution vivants

daemon

Một giá trị boolean cho biết luồng này có phải là luồng daemon [

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07] hay không [
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12]. Điều này phải được thiết lập trước khi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
93 được gọi, nếu không thì 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 được nâng lên. Giá trị ban đầu của nó được kế thừa từ chuỗi tạo;

Le program Python se termine lorsqu'il ne reste plus de fils d'exécution non-demons vivants

isDaemon[]setDaemon[]

API getter/setter không dùng nữa cho 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
24;

Obsolète depuis la phiên bản 3. 10

Verrous¶

Un verrou primitif n'appartient pas à un fil d'exécution lorsqu'il est verrouillé. Trong Python, c'est actuellement la méthode de sync la plus bas-niveau qui soit disponible, implémentée directement par le module d'extension 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
3

Un verrou primitif est soit « verrouillé » soit « déverrouillé ». Il est créé dans un état déverrouillé. Il a deux méthodes, 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 et 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20. Lorsque l'état est déverrouillé, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 verrouille et se termine immédiatement. Lorsque l'état est verrouillé, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 bloque jusqu'à ce qu'un appel à 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 Provenant d'un autre fil d'exécution le déverrouille. À ce moment 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 le verrouille à nouveau et rend la main. La méthode 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 ne doit être appelée que si le verrou est verrouillé, elle le déverrouille alors et se termine imédiatement. Déverrouiller un verrou qui n'est pas verrouillé provoque une 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70

Khóa cũng hỗ trợ giao thức quản lý ngữ cảnh .

Khi có nhiều luồng bị chặn trong 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 đang chờ trạng thái chuyển sang mở khóa, chỉ một luồng tiếp tục khi lệnh gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 đặt lại trạng thái thành mở khóa;

Tất cả các phương pháp được thực hiện nguyên tử

lớp phân luồng. Khóa

Lớp triển khai các đối tượng khóa nguyên thủy. Khi một luồng đã có được khóa, các nỗ lực tiếp theo để có được khối đó, cho đến khi nó được giải phóng;

Lưu ý rằng 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
29 thực sự là một hàm xuất xưởng trả về một phiên bản hiệu quả nhất của lớp Khóa cụ thể được nền tảng hỗ trợ

có được[chặn=Đúng, timeout=- 1]

Acquiert un verrou, bloquant ou non bloquant

Khi được gọi với đối số chặn được đặt thành 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 [mặc định], hãy chặn cho đến khi khóa được mở khóa, sau đó đặt thành bị khóa và trả về 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07

Khi được gọi với đối số chặn được đặt thành 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12, không chặn. Nếu một cuộc gọi có chặn được đặt thành 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 sẽ chặn, hãy trả lại 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 ngay lập tức;

Khi được gọi với đối số thời gian chờ dấu phẩy động được đặt thành giá trị dương, hãy chặn tối đa số giây được chỉ định theo thời gian chờ và miễn là không thể lấy được khóa. Đối số thời gian chờ của 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
36 chỉ định thời gian chờ không giới hạn. Cấm chỉ định thời gian chờ khi chặn là 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12

Giá trị trả về là 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 nếu khóa được lấy thành công, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 nếu không [ví dụ: nếu hết thời gian chờ]

Sửa đổi ở phiên bản 3. 2. Le paramètre timeout est nouveau.

Sửa đổi ở phiên bản 3. 2. Việc thu thập khóa hiện có thể bị gián đoạn bởi các tín hiệu trên POSIX nếu triển khai luồng cơ bản hỗ trợ nó.

bản phát hành[]

Phát hành một khóa. Điều này có thể được gọi từ bất kỳ luồng nào, không chỉ luồng đã lấy khóa

Khi khóa bị khóa, đặt lại thành mở khóa và quay lại. Nếu bất kỳ chủ đề nào khác bị chặn đang chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiếp tục

Khi được gọi trên một ổ khóa đã được mở khóa, một 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 được nâng lên

Il n'y a pas de valeur de retour

bị khóa[]

Trả lại 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 nếu khóa được mua

RLock đối tượng¶

Khóa reentrant là nguyên thủy đồng bộ hóa có thể được mua lại nhiều lần bởi cùng một luồng. Trong nội bộ, nó sử dụng các khái niệm "chủ đề sở hữu" và "mức đệ quy" ngoài trạng thái khóa/mở khóa được sử dụng bởi các khóa nguyên thủy. Ở trạng thái bị khóa, một số luồng sở hữu khóa;

Để khóa khóa, một luồng gọi phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 của nó; . Để mở khóa, một luồng gọi phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 của nó. Các cặp cuộc gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19/
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 có thể được lồng vào nhau;

Khóa người gửi lại cũng hỗ trợ giao thức quản lý bối cảnh .

lớp phân luồng. RLock

Lớp này thực hiện các đối tượng khóa reentrant. Một khóa reentrant phải được phát hành bởi chủ đề có được nó. Khi một luồng đã nhận được khóa truy cập lại, luồng đó có thể lấy lại khóa đó mà không bị chặn;

Lưu ý rằng 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49 thực sự là một hàm xuất xưởng trả về một phiên bản hiệu quả nhất của lớp RLock cụ thể được nền tảng hỗ trợ

có được[chặn=Đúng, timeout=- 1]

Acquiert un verrou, bloquant ou non bloquant

Khi được gọi mà không có đối số. nếu chủ đề này đã sở hữu khóa, hãy tăng mức đệ quy lên một và quay lại ngay lập tức. Mặt khác, nếu một chủ đề khác sở hữu khóa, hãy chặn cho đến khi khóa được mở khóa. Khi khóa được mở khóa [không thuộc sở hữu của bất kỳ chủ đề nào], sau đó lấy quyền sở hữu, đặt mức đệ quy thành một và quay lại. Nếu có nhiều luồng bị chặn chờ cho đến khi khóa được mở khóa, thì mỗi lần chỉ một luồng có thể giành quyền sở hữu khóa. Không có giá trị trả lại trong trường hợp này

Khi được gọi với đối số chặn được đặt thành 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07, hãy thực hiện tương tự như khi được gọi mà không có đối số và trả về 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07

Khi được gọi với đối số chặn được đặt thành 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12, không chặn. Nếu một cuộc gọi không có đối số sẽ bị chặn, hãy trả lại 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 ngay lập tức;

Khi được gọi với đối số thời gian chờ dấu phẩy động được đặt thành giá trị dương, hãy chặn tối đa số giây được chỉ định theo thời gian chờ và miễn là không thể lấy được khóa. Trả lại 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 nếu đã lấy được khóa, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 nếu hết thời gian chờ

Sửa đổi ở phiên bản 3. 2. Le paramètre timeout est nouveau.

bản phát hành[]

Phát hành khóa, giảm mức đệ quy. Nếu sau khi giảm, nó bằng 0, hãy đặt lại khóa thành mở khóa [không thuộc sở hữu của bất kỳ chuỗi nào] và nếu bất kỳ chuỗi nào khác bị chặn đang chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiếp tục. Nếu sau khi giảm, mức đệ quy vẫn khác không, thì khóa vẫn bị khóa và thuộc sở hữu của luồng gọi

Chỉ gọi phương thức này khi luồng gọi sở hữu khóa. Một 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 được nâng lên nếu phương thức này được gọi khi khóa được mở khóa

Il n'y a pas de valeur de retour

Đối tượng điều kiện¶

Một biến điều kiện luôn được liên kết với một số loại khóa; . Truyền một vào rất hữu ích khi một số biến điều kiện phải chia sẻ cùng một khóa. Khóa là một phần của đối tượng điều kiện. bạn không cần phải theo dõi nó một cách riêng biệt

Biến điều kiện tuân theo giao thức quản lý ngữ cảnh . sử dụng câu lệnh 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
58 để có được khóa liên quan trong suốt thời gian của khối kèm theo. Các phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 cũng gọi các phương thức tương ứng của khóa được liên kết.

Các phương thức khác phải được gọi với khóa liên quan được giữ. Phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 giải phóng khóa, sau đó chặn cho đến khi một luồng khác đánh thức nó bằng cách gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 hoặc 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
63. Sau khi được đánh thức, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 lấy lại khóa và quay trở lại. Cũng có thể chỉ định thời gian chờ

Phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 đánh thức một trong các luồng đang chờ biến điều kiện, nếu có đang chờ. Phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
63 đánh thức tất cả các luồng đang chờ biến điều kiện

Ghi chú. các phương pháp 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
63 không giải phóng khóa;

Phong cách lập trình điển hình sử dụng các biến điều kiện sử dụng khóa để đồng bộ hóa quyền truy cập vào một số trạng thái được chia sẻ; . Ví dụ: đoạn mã sau là tình huống chung giữa nhà sản xuất và người tiêu dùng với dung lượng bộ đệm không giới hạn

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]

Việc kiểm tra vòng lặp 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
75 cho điều kiện của ứng dụng là cần thiết vì 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 có thể quay lại sau một thời gian dài tùy ý và điều kiện khiến cuộc gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 có thể không còn đúng nữa. Đây là vốn có của lập trình đa luồng. Phương pháp 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
78 có thể được sử dụng để tự động hóa việc kiểm tra điều kiện và giảm bớt việc tính toán thời gian chờ

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
9

Để chọn giữa 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
63, hãy xem xét liệu một thay đổi trạng thái có thể thú vị đối với chỉ một hoặc một số luồng đang chờ hay không. e. g. trong một tình huống điển hình của nhà sản xuất-người tiêu dùng, việc thêm một mục vào bộ đệm chỉ cần đánh thức một luồng người tiêu dùng

lớp phân luồng. Điều kiện[khóa=Không]

Lớp này thực hiện các đối tượng biến điều kiện. Một biến điều kiện cho phép một hoặc nhiều luồng đợi cho đến khi chúng được thông báo bởi một luồng khác

Nếu đối số khóa được đưa ra và không phải là 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, thì đối số đó phải là đối tượng 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
29 hoặc 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49 và được sử dụng làm khóa cơ bản. Mặt khác, một đối tượng 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49 mới được tạo và sử dụng làm khóa bên dưới

Sửa đổi ở phiên bản 3. 3. đã thay đổi từ hàm xuất xưởng thành lớp.

thu được[*đối số]

Có được khóa cơ bản. Phương thức này gọi phương thức tương ứng trên khóa bên dưới;

bản phát hành[]

Thả khóa bên dưới. Phương thức này gọi phương thức tương ứng trên khóa bên dưới;

chờ[hết thời gian=Không có]

Đợi cho đến khi được thông báo hoặc cho đến khi hết thời gian chờ. Nếu chuỗi cuộc gọi chưa nhận được khóa khi phương thức này được gọi, thì một 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 sẽ xuất hiện

Phương pháp này giải phóng khóa cơ bản, sau đó chặn cho đến khi nó được đánh thức bằng lệnh gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 hoặc 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
63 cho cùng một biến điều kiện trong một chuỗi khác hoặc cho đến khi hết thời gian chờ tùy chọn xảy ra. Sau khi được đánh thức hoặc hết thời gian chờ, nó sẽ lấy lại khóa và quay lại

Khi đối số hết thời gian chờ xuất hiện chứ không phải 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, thì đó phải là số dấu phẩy động chỉ định thời gian chờ cho thao tác tính bằng giây [hoặc phân số của nó]

Khi khóa cơ bản là một 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49, nó không được giải phóng bằng phương pháp 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 của nó, vì điều này có thể không thực sự mở khóa khi nó được mua lại nhiều lần theo cách đệ quy. Thay vào đó, một giao diện bên trong của lớp 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49 được sử dụng, giao diện này thực sự mở khóa nó ngay cả khi nó đã được thu thập một cách đệ quy nhiều lần. Sau đó, một giao diện nội bộ khác được sử dụng để khôi phục mức đệ quy khi khóa được lấy lại

Giá trị trả về là 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 trừ khi hết thời gian chờ nhất định, trong trường hợp đó là 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12

Sửa đổi ở phiên bản 3. 2. Trước đây, phương thức luôn trả về 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9.

wait_for[predicate , timeout=None]

Chờ cho đến khi một điều kiện đánh giá là đúng. vị ngữ phải là một giá trị có thể gọi được, kết quả sẽ được hiểu là giá trị boolean. Thời gian chờ có thể được cung cấp cho thời gian chờ tối đa

Phương thức tiện ích này có thể gọi liên tục 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 cho đến khi vị từ được thỏa mãn hoặc cho đến khi hết thời gian chờ. Giá trị trả về là giá trị trả về cuối cùng của vị từ và sẽ đánh giá thành 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 nếu phương thức hết thời gian chờ

Bỏ qua tính năng hết thời gian chờ, việc gọi phương thức này gần tương đương với việc viết

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
7

Do đó, các quy tắc tương tự được áp dụng như với 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61. Khóa phải được giữ khi được gọi và được lấy lại khi trả lại. Vị từ được đánh giá với khóa được giữ

Mới nhất dans la phiên bản 3. 2

thông báo[n=1]

Theo mặc định, đánh thức một luồng đang chờ trong điều kiện này, nếu có. Nếu chuỗi cuộc gọi chưa nhận được khóa khi phương thức này được gọi, thì một 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 sẽ xuất hiện

Phương thức này đánh thức tối đa n luồng đang chờ biến điều kiện;

Việc triển khai hiện tại đánh thức đúng n luồng, nếu có ít nhất n luồng đang chờ. Tuy nhiên, không an toàn khi dựa vào hành vi này. Việc triển khai được tối ưu hóa trong tương lai đôi khi có thể đánh thức hơn n luồng

Ghi chú. một luồng được đánh thức không thực sự quay trở lại từ cuộc gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 của nó cho đến khi nó có thể lấy lại khóa. Vì 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62 không nhả khóa nên người gọi nó phải

notify_all[]

Đánh thức tất cả các chủ đề đang chờ trong điều kiện này. Phương pháp này hoạt động giống như 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
62, nhưng đánh thức tất cả các luồng đang chờ thay vì một. Nếu chuỗi cuộc gọi chưa nhận được khóa khi phương thức này được gọi, thì một 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70 sẽ xuất hiện

Phương thức 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
03 là bí danh không dùng nữa cho phương thức này

Đối tượng Semaphore¶

Đây là một trong những nguyên tắc đồng bộ hóa lâu đời nhất trong lịch sử khoa học máy tính, được phát minh bởi nhà khoa học máy tính đầu tiên người Hà Lan Edsger W. Dijkstra [anh ấy đã sử dụng tên 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
04 và 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
05 thay vì 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20]

Một semaphore quản lý một bộ đếm nội bộ được giảm dần theo mỗi cuộc gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 và tăng lên theo mỗi cuộc gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20. Bộ đếm không bao giờ có thể xuống dưới 0;

Semaphores cũng hỗ trợ giao thức quản lý ngữ cảnh .

lớp phân luồng. Semaphore[giá trị=1]

Lớp này cài đặt các đối tượng semaphore. Một semaphore quản lý một bộ đếm nguyên tử đại diện cho số cuộc gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 trừ đi số lượng cuộc gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19, cộng với một giá trị ban đầu. Phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 chặn nếu cần cho đến khi nó có thể trả về mà không làm cho bộ đếm âm. Nếu không được cung cấp, giá trị mặc định là 1

Đối số tùy chọn đưa ra giá trị ban đầu cho bộ đếm nội bộ; . Nếu giá trị đã cho nhỏ hơn 0, thì 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
71 được nâng lên

Sửa đổi ở phiên bản 3. 3. đã thay đổi từ hàm xuất xưởng thành lớp.

có được[chặn=Đúng, timeout=None]

Có được một semaphore

Khi được gọi mà không có đối số

  • Nếu bộ đếm bên trong lớn hơn 0 khi nhập, hãy giảm nó đi một và trả về 

    >>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
    07 ngay lập tức

  • Nếu bộ đếm bên trong bằng 0 khi vào, hãy chặn cho đến khi được đánh thức bằng lệnh gọi tới 

    >>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
    20. Sau khi được đánh thức [và bộ đếm lớn hơn 0], giảm bộ đếm đi 1 và trả về 
    >>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
    07. Chính xác một chủ đề sẽ được đánh thức bởi mỗi cuộc gọi đến 
    >>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
    20. Không nên dựa vào thứ tự các luồng được đánh thức

Khi được gọi với tính năng chặn được đặt thành 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12, không chặn. Nếu một cuộc gọi không có đối số sẽ bị chặn, hãy trả lại 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12 ngay lập tức;

Khi được gọi với thời gian chờ khác với 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, nó sẽ chặn trong tối đa giây hết thời gian chờ. Nếu thu được không hoàn thành thành công trong khoảng thời gian đó, hãy trả lại 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
12. Trả lại 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 nếu không

Sửa đổi ở phiên bản 3. 2. Le paramètre timeout est nouveau.

phát hành[n=1]

Phát hành một semaphore, tăng bộ đếm bên trong lên n. Khi nó bằng 0 trên mục nhập và các luồng khác đang chờ nó trở lại lớn hơn 0 lần nữa, hãy đánh thức n trong số các luồng đó

Sửa đổi ở phiên bản 3. 9. Đã thêm tham số n để giải phóng nhiều luồng đang chờ cùng một lúc.

lớp phân luồng. BoundedSemaphore[giá trị=1]

Lớp triển khai các đối tượng semaphore có giới hạn. Semaphore có giới hạn kiểm tra để đảm bảo giá trị hiện tại của nó không vượt quá giá trị ban đầu. Nếu có, 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
71 được nâng lên. Trong hầu hết các tình huống, đèn hiệu được sử dụng để bảo vệ các tài nguyên có dung lượng hạn chế. Nếu semaphore được phát hành quá nhiều lần, đó là dấu hiệu của một lỗi. Nếu không được cung cấp, giá trị mặc định là 1

Sửa đổi ở phiên bản 3. 3. đã thay đổi từ hàm xuất xưởng thành lớp. 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
28 Ví dụ¶

Semaphores thường được sử dụng để bảo vệ các tài nguyên có dung lượng hạn chế, chẳng hạn như máy chủ cơ sở dữ liệu. Trong bất kỳ tình huống nào mà kích thước của tài nguyên là cố định, bạn nên sử dụng một semaphore có giới hạn. Trước khi sinh ra bất kỳ luồng worker nào, luồng chính của bạn sẽ khởi tạo semaphore

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
7

Sau khi được sinh ra, worker thread gọi các phương thức thu thập và giải phóng của semaphore khi chúng cần kết nối với máy chủ

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
9

Việc sử dụng semaphore có giới hạn giúp giảm khả năng lỗi lập trình khiến semaphore được giải phóng nhiều hơn mức thu được sẽ không bị phát hiện

Đối tượng sự kiện¶

Đây là một trong những cơ chế đơn giản nhất để giao tiếp giữa các luồng. một luồng báo hiệu một sự kiện và các luồng khác chờ đợi nó

Một đối tượng sự kiện quản lý một cờ nội bộ có thể được đặt thành true bằng phương thức 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
29 và đặt lại thành false bằng phương thức 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
30. Phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 chặn cho đến khi cờ là true

lớp phân luồng. Sự kiện

Lớp thực hiện các đối tượng sự kiện. Một sự kiện quản lý một cờ có thể được đặt thành true bằng phương thức 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
29 và đặt lại thành false bằng phương thức 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
30. Phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 chặn cho đến khi cờ là true. Cờ ban đầu là sai

Sửa đổi ở phiên bản 3. 3. đã thay đổi từ hàm xuất xưởng thành lớp.

is_set[]

Trả lại 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 khi và chỉ khi cờ nội bộ là đúng

Phương thức 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
36 là bí danh không dùng nữa cho phương thức này

đặt[]

Đặt cờ nội bộ thành true. Tất cả các chủ đề đang chờ nó trở thành sự thật được đánh thức. Các chủ đề gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 sau khi cờ là đúng sẽ không bị chặn

xóa[]

Đặt lại cờ nội bộ thành sai. Sau đó, các chủ đề gọi 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 sẽ chặn cho đến khi 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
29 được gọi để đặt lại cờ nội bộ thành true

chờ[hết thời gian=Không có]

Chặn cho đến khi cờ nội bộ là true. Nếu cờ nội bộ là đúng khi vào, hãy quay lại ngay lập tức. Nếu không, hãy chặn cho đến khi một luồng khác gọi 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
29 để đặt cờ thành true hoặc cho đến khi hết thời gian chờ tùy chọn xảy ra

Khi đối số hết thời gian chờ xuất hiện chứ không phải 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9, thì đó phải là số dấu phẩy động chỉ định thời gian chờ cho thao tác tính bằng giây [hoặc phân số của nó]

Phương thức này trả về 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 khi và chỉ khi cờ nội bộ đã được đặt thành true, trước cuộc gọi chờ hoặc sau khi bắt đầu chờ, do đó, nó sẽ luôn trả về 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 trừ khi hết thời gian chờ và thao tác hết thời gian chờ

Sửa đổi ở phiên bản 3. 1. Trước đây, phương thức luôn trả về 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9.

Đối tượng hẹn giờ¶

Lớp này đại diện cho một hành động chỉ được chạy sau một khoảng thời gian nhất định --- một bộ đếm thời gian. 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
45 là một phân lớp của 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
2 và như vậy cũng có chức năng như một ví dụ về tạo chủ đề tùy chỉnh

Bộ hẹn giờ được bắt đầu, như với các luồng, bằng cách gọi phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
93 của chúng. Có thể dừng bộ đếm thời gian [trước khi hành động của nó bắt đầu] bằng cách gọi phương thức 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
48. Khoảng thời gian mà bộ hẹn giờ sẽ đợi trước khi thực hiện hành động của nó có thể không hoàn toàn giống với khoảng thời gian do người dùng chỉ định

ví dụ

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
2

lớp phân luồng. Bộ hẹn giờ[khoảng thời gian , chức năng, args=None, kwargs=None]

Tạo một bộ đếm thời gian sẽ chạy chức năng với các đối số args và đối số từ khóa kwargs, sau khi khoảng thời gian giây trôi qua. Nếu đối số là 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 [mặc định] thì một danh sách trống sẽ được sử dụng. Nếu kwargs là 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
9 [mặc định] thì một lệnh trống sẽ được sử dụng

Sửa đổi ở phiên bản 3. 3. đã thay đổi từ hàm xuất xưởng thành lớp.

hủy[]

Dừng bộ đếm thời gian và hủy bỏ việc thực hiện hành động của bộ đếm thời gian. Điều này sẽ chỉ hoạt động nếu bộ hẹn giờ vẫn đang trong giai đoạn chờ

Đối tượng rào cản¶

Mới nhất dans la phiên bản 3. 2

Lớp này cung cấp một nguyên mẫu đồng bộ hóa đơn giản để sử dụng bởi một số luồng cố định cần đợi lẫn nhau. Mỗi luồng cố gắng vượt qua rào cản bằng cách gọi phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 và sẽ chặn cho đến khi tất cả các luồng đã thực hiện cuộc gọi 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 của họ. Tại thời điểm này, các luồng được giải phóng đồng thời

Rào chắn có thể được tái sử dụng nhiều lần cho cùng một số luồng

Ví dụ, đây là một cách đơn giản để đồng bộ hóa luồng máy khách và máy chủ

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
8

lớp phân luồng. Rào cản[các bên , hành động=None, timeout=None]

Tạo một đối tượng rào cản cho các bên số chủ đề. Một hành động, khi được cung cấp, là một hành động có thể gọi được để được gọi bởi một trong các luồng khi chúng được giải phóng. thời gian chờ là giá trị thời gian chờ mặc định nếu không có giá trị nào được chỉ định cho phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61

chờ[hết thời gian=Không có]

Vượt qua rào cản. Khi tất cả các chủ đề tham gia rào cản đã gọi chức năng này, tất cả chúng sẽ được giải phóng đồng thời. Nếu thời gian chờ được cung cấp, nó sẽ được sử dụng ưu tiên hơn bất kỳ thời gian chờ nào được cung cấp cho hàm tạo của lớp

Giá trị trả về là một số nguyên trong phạm vi từ 0 đến bên -- 1, khác nhau đối với từng luồng. Điều này có thể được sử dụng để chọn một chủ đề để thực hiện một số công việc vệ sinh đặc biệt, e. g

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
50

Nếu một hành động được cung cấp cho hàm tạo, thì một trong các luồng sẽ gọi nó trước khi được giải phóng. Nếu cuộc gọi này gây ra lỗi, rào cản sẽ được đưa vào trạng thái bị hỏng

Nếu cuộc gọi hết thời gian, rào cản được đưa vào trạng thái bị hỏng

Phương pháp này có thể tăng ngoại lệ 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
54 nếu rào cản bị hỏng hoặc đặt lại trong khi luồng đang chờ

đặt lại[]

Trả hàng rào về trạng thái trống, mặc định. Bất kỳ chủ đề nào đang chờ nó sẽ nhận được ngoại lệ 

# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
54

Lưu ý rằng việc sử dụng chức năng này có thể yêu cầu một số đồng bộ hóa bên ngoài nếu có các luồng khác không xác định được trạng thái. Nếu một rào cản bị phá vỡ, có thể tốt hơn là bỏ nó đi và tạo một rào cản mới

hủy bỏ[]

Đặt rào cản vào trạng thái bị hỏng. Điều này khiến mọi cuộc gọi đang hoạt động hoặc trong tương lai tới 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
61 không thành công với 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
54. Sử dụng ví dụ này nếu một trong các luồng cần hủy bỏ, để tránh làm bế tắc ứng dụng

Có thể tốt hơn là chỉ cần tạo rào cản với giá trị thời gian chờ hợp lý để tự động bảo vệ chống lại một trong các luồng bị trục trặc

các bên

Số lượng chủ đề cần thiết để vượt qua rào cản

n_waiting

Số lượng chủ đề hiện đang chờ đợi trong hàng rào

hỏng

Một boolean là 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
07 nếu hàng rào ở trạng thái bị hỏng

ngoại lệ phân luồng. Lỗi BrokenBarrier

Ngoại lệ này, một lớp con của 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
70, được đưa ra khi đối tượng 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
60 được đặt lại hoặc bị hỏng

Sử dụng khóa, điều kiện và dấu hiệu trong câu lệnh 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
58¶

Tất cả các đối tượng được cung cấp bởi mô-đun này có các phương thức 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 có thể được sử dụng làm trình quản lý ngữ cảnh cho câu lệnh 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
58. Phương thức 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
19 sẽ được gọi khi khối được nhập và 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
20 sẽ được gọi khi khối được thoát. Do đó, đoạn mã sau

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
0

est équivalente à

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
1

Hiện tại, các đối tượng 

>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
29, 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
49, 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
69, 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
28 và 
# Consume one item
with cv:
    while not an_item_is_available[]:
        cv.wait[]
    get_an_available_item[]

# Produce one item
with cv:
    make_an_item_available[]
    cv.notify[]
71 có thể được sử dụng làm trình quản lý ngữ cảnh câu lệnh 
>>> from threading import Thread
>>> t = Thread[target=print, args=[1]]
>>> t.run[]
1
>>> t = Thread[target=print, args=[1,]]
>>> t.run[]
1
58

Bài Viết Liên Quan

Khi nào tôi có thể sử dụng sum() trong Python?
Coldplay Amsterdam 2023 prize
Python thử bắt ngoại lệ
Firefox không vào được mạng trên kali linux
Tại sao python không phải là ngôn ngữ đầu tiên tốt?
Hoạt động nội bộ của từ điển trong python
Tôi có thể tạo biểu mẫu google từ bảng tính hiện có không?
Tuyên bố sử dụng động php
Đầu ra hệ điều hành python
Làm thế nào để bạn liệt kê các số nguyên trong python?
Eclipse calendar 2024
Lịch 2023 rhineland-palatinate với các ngày lễ excel
Đã chuyển wordpress sang máy chủ mới hiện đang cố tải xuống một tệp
Một con trăn bóng có thể nặng bao nhiêu?
Dấu phẩy python sau biến
Int có bất biến trong python không?
Fortuner 2015 giá bao nhiêu
MySQL là gì Chức năng và tính năng của nó là gì Lớp 11?
Làm thế nào để bạn gắn thẻ html trong python?
Google bài phát biểu thành văn bản websocket python

Toplist mới

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
7 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
7 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
7 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
7 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
7 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
7 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
7 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
7 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
7 tháng trước

Bài mới nhất

Cách dạy con học toán lớp 1 hiệu quả năm 2024
Hàm trung bình cộng trong thư viện math.h năm 2024
Khi chạy chương trình báo lỗi invalid missing system.setup năm 2024
Bài giảng sự lai hóa các obitan phân tử năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Bài Tập Địa Điểm Hay Mẹo Hay Học Tốt Nghĩa của từ Công Nghệ Khỏe Đẹp bao nhiêu Top List Tiếng anh Bao nhiêu Sản phẩm tốt Xây Đựng Ngôn ngữ javascript Ở đâu Đại học Hướng dẫn Bài tập Tại sao Dịch So Sánh Máy tính Món Ngon mẹo hay Bao lâu Thế nào So sánh Khoa Học Vì sao Lớp 9 Lớp 10