Hướng dẫn what is the purpose of threading lock () in python? - mục đích của luồng khóa () trong python là gì?

Dữ liệu địa lý địa lý

Dữ liệu địa lý địa chỉ là dữ liệu có giá trị cụ thể của luồng. Để quản lý dữ liệu địa lý, chỉ cần tạo một thể hiện là

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

mydata = threading.local()
mydata.x = 1

Các giá trị của phiên bản sẽ khác nhau đối với các luồng riêng biệt.

Một lớp đại diện cho dữ liệu địa lý.

Để biết thêm chi tiết và các ví dụ mở rộng, hãy xem chuỗi tài liệu của mô -đun

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

Đối tượng chủ đề

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()

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

Khi một đối tượng luồng được tạo, hoạt động của nó phải được bắt đầu bằng cách gọi phương thức luồng ____ ____998. Điều này gọi phương thức

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

Khi hoạt động của chủ đề được bắt đầu, chủ đề được coi là ‘còn sống. Nó ngừng sống khi phương pháp

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Các luồng khác có thể gọi phương thức chủ đề

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Một chủ đề có một tên. Tên có thể được chuyển cho hàm tạo và đọc hoặc thay đổi thông qua thuộc tính

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Nếu phương thức

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Một chủ đề có thể được gắn cờ dưới dạng chủ đề Daemon Daemon. Tầm quan trọng của lá cờ này là toàn bộ chương trình Python thoát ra khi chỉ còn lại các luồng daemon. Giá trị ban đầu được kế thừa từ chủ đề tạo. Cờ có thể được đặt thông qua thuộc tính

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Ghi chú

Chủ đề daemon đột ngột dừng lại khi tắt máy. Tài nguyên của họ (như các tệp mở, giao dịch cơ sở dữ liệu, v.v.) không được phát hành đúng. Nếu bạn muốn các chủ đề của mình dừng lại một cách duyên dáng, hãy làm cho chúng không phải là Daemonic và sử dụng một cơ chế báo hiệu phù hợp như

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Có một đối tượng chủ đề chính của người Viking; Điều này tương ứng với luồng điều khiển ban đầu trong chương trình Python. Nó không phải là một chủ đề daemon.

Có khả năng các đối tượng chủ đề giả của người Viking được tạo ra. Đây là các đối tượng chủ đề tương ứng với các chủ đề của người ngoài hành tinh, đó là các 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 chủ đề giả có chức năng hạn chế; Chúng luôn được coi là sống và daemonic, và không thể được ____102ed. Họ không bao giờ bị xóa, vì không thể phát hiện việc chấm dứt các chủ đề ngoài hành tinh.

Trình xây dựng này phải luôn luôn được gọi với các đối số từ khóa. Đối số là:

Nhóm phải là

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Mục tiêu là đối tượng có thể gọi được được gọi bằng phương thức

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Tên là tên chủ đề. Theo mặc định, một tên duy nhất được xây dựng theo mẫu của chủ đề n, trong đó n là một số thập phân nhỏ, hoặc chủ đề của N (mục tiêu), trong đó, mục tiêu là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

args là tuple đối số cho việc gọi mục tiêu. Mặc định là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

KWARGS là một từ điển của các đối số từ khóa cho việc gọi mục tiêu. Mặc định là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Nếu không phải là

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Nếu lớp con ghi đè hàm tạo, nó phải đảm bảo gọi hàm tạo lớp cơ sở (

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.10: Sử dụng tên đích nếu đối số tên bị bỏ qua.Use the target name if name argument is omitted.

Đã thay đổi trong phiên bản 3.3: Đã thêm đối số daemon.Added the daemon argument.

Bắt đầu hoạt động chủ đề.

Nó phải được gọi nhiều nhất một lần cho mỗi đối tượng chủ đề. Nó sắp xếp cho phương thức đối tượng ____ ____67 được gọi trong một luồng điều khiển riêng biệt.

Phương pháp này sẽ tăng

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Phương pháp đại diện cho hoạt động của chủ đề.

Bạn có thể ghi đè phương thức này trong một lớp con. Phương thức

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

Đợi cho đến khi chủ đề chấm dứt. Điều này chặn luồng gọi cho đến khi luồng có phương thức

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Khi đối số thời gian chờ có mặt chứ không phải

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Khi đối số thời gian chờ không có hoặc

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Một chủ đề có thể được

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads



thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads 
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Một chuỗi được sử dụng cho mục đích nhận dạng. Nó không có ngữ nghĩa. Nhiều luồng có thể được đặt cùng một tên. Tên ban đầu được đặt bởi hàm tạo.

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Không dùng nữa kể từ phiên bản 3.10.

Định danh ’luồng của chủ đề này hoặc

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

ID luồng (

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Ghi chú

Tương tự như ID xử lý, ID luồng chỉ hợp lệ (được bảo đảm toàn bộ hệ thống) kể từ khi luồng được tạo cho đến khi luồng bị chấm dứt.

Tính khả dụng: Yêu cầu chức năng

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Mới trong phiên bản 3.8.

Trả lại liệu chủ đề còn sống.

Phương pháp này trả về

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

# 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()

Giá trị boolean cho biết liệu luồng này có phải là luồng daemon hay không (

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Toàn bộ chương trình Python thoát ra khi không còn chủ đề không phải là Daemon.

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Không dùng nữa kể từ phiên bản 3.10.

________ 146¶

Định danh ’luồng của chủ đề này hoặc

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

________ 149¶

Khóa cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

Khi có nhiều hơn một luồng bị chặn trong

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Tất cả các phương pháp được thực thi về mặt nguyên tử.

Lớp thực hiện các đối tượng khóa nguyên thủy. Khi một luồng đã có được một khóa, các nỗ lực tiếp theo để có được khối nó, cho đến khi nó được phát hành; Bất kỳ chủ đề có thể phát hành nó.

Lưu ý rằng

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Có được một khóa, chặn hoặc không chặn.

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Khi được gọi với đối số thời gian chờ điểm nổi được đặt thành giá trị dương, khối trong nhiều nhất số giây được chỉ định bởi thời gian chờ và miễn là khóa không thể có được. Một đối số thời gian chờ của

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Giá trị trả về là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 



thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

Đã thay đổi trong phiên bản 3.2: Việc thu nhận khóa hiện có thể bị gián đoạn bởi các tín hiệu trên POSIX nếu việc triển khai luồng cơ bản hỗ trợ nó.Lock acquisition can now be interrupted by signals on POSIX if the underlying threading implementation supports it.

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

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

Khi được gọi trên một khóa không khóa, một

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Không có giá trị quay lại.

Trả lại

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đối tượng rlock

Khóa reentrant là một nguyên thủy đồng bộ hóa có thể có được 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 về việc sở hữu chủ đề của người Hồi giáo và cấp độ đệ quy, ngoài trạng thái bị 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ố chủ đề sở hữu khóa; Trong trạng thái mở khóa, không có chủ đề sở hữu nó.

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Khóa reentrant cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

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 đã có được một khóa reentrant, cùng một luồng có thể có được nó một lần nữa mà không chặn; Chủ đề phải phát hành nó một lần cho mỗi lần nó có được nó.

Lưu ý rằng

mydata = threading.local()
mydata.x = 1

Có được một khóa, chặn hoặc không chặn.

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Khi được gọi với đối số thời gian chờ điểm nổi được đặt thành giá trị dương, khối trong nhiều nhất số giây được chỉ định bởi thời gian chờ và miễn là khóa không thể có được. Một đối số thời gian chờ của

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Giá trị trả về là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

Phát hành khóa, giảm mức đệ quy. Nếu sau khi giảm, nó bằng không, hãy đặt lại khóa để mở khóa (không thuộc sở hữu của bất kỳ luồng nào) và nếu bất kỳ luồng nào khác bị chặn chờ khóa được mở khóa, hãy cho phép chính xác một trong số chúng tiến hành. Nếu sau khi giảm mức đệ quy vẫn còn khác, thì khóa vẫn bị khóa và sở hữu bởi 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

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Không có giá trị quay lại.

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

Một biến điều kiện luôn được liên kết với một số loại khóa; Điều này có thể được thông qua hoặc một sẽ được tạo theo mặc định. Vượt qua một trong là 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 phải theo dõi nó một cách riêng biệt.

Một biến điều kiện tuân theo giao thức quản lý bối cảnh: Sử dụng câu lệnh

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Phương pháp

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Lưu ý: Phương pháp

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Kiểu 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 chung; Các chủ đề quan tâm đến một sự thay đổi cụ thể của cuộc gọi trạng thái

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

# 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()

Vòng lặp

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Để lựa chọn giữa

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

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 chờ đợ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 chứ không phải

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

Có được khóa cơ bản. Phương pháp này gọi phương thức tương ứng trên khóa bên dưới; Giá trị trả về là bất cứ điều gì phương thức đó trả về.

Phát hành khóa cơ bản. Phương pháp này gọi phương thức tương ứng trên khóa bên dưới; không có giá trị quay lại.

Chờ cho đến khi được thông báo hoặc cho đến khi thời gian chờ xảy ra. Nếu luồng cuộc gọi không có được khóa khi phương thức này được gọi, một

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Phương pháp này phát hành khóa bên dưới, và sau đó chặn cho đến khi nó được đánh thức bởi một cuộc gọi

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Khi đối số thời gian chờ có mặt chứ không phải

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Khi khóa bên dưới là

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

mydata = threading.local()
mydata.x = 1

Giá trị trả về là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.2: Trước đây, phương thức luôn được trả về

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

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

Phương pháp tiện ích này có thể gọi

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

while not predicate():
    cv.wait()

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

mydata = threading.local()
mydata.x = 1

Mới trong phiên bản 3.2.

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

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Phương pháp này thức dậy nhiều nhất n của các luồng đang chờ biến điều kiện; Đó là một không có nếu không có chủ đề đang chờ đợi.

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

Lưu ý: Một luồng đánh thức không thực sự quay lại từ cuộc gọi

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Thức dậy tất cả các chủ đề đang chờ đợi điều kiện này. Phương pháp này hoạt động như

mydata = threading.local()
mydata.x = 1

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Phương pháp

mydata = threading.local()
mydata.x = 1

Đối tượng semaphore

Đây là một trong những nguyên thủy đồ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 của Hà Lan Edsger W. Dijkstra (ông đã sử dụng tên

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Một semaphore quản lý một bộ đếm nội bộ bị giảm bởi mỗi cuộc gọi

# Importing the threading module



import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
 global deposit
 for i in range(100000):
 lock.acquire()
 deposit = deposit + 10
 lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
 global deposit
 for i in range(100000):
 lock.acquire()
 deposit = deposit - 10
 lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads 
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Semaphores cũng hỗ trợ giao thức quản lý bối cảnh.context management protocol.

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đối số tùy chọn cho giá trị ban đầu cho bộ đếm nội bộ; Nó mặc định là

mydata = threading.local()
mydata.x = 1

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

Có được một semaphore.

Khi được gọi mà không có tranh luận:

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

  # Importing the threading module
  import threading 
  # Declraing a lock
  lock = threading.Lock()
  deposit = 100
  # Function to add profit to the deposit
  def add_profit(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit + 10
          lock.release()
  # Function to deduct money from the deposit
  def pay_bill(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit - 10
          lock.release()
  # Creating threads
  thread1 = threading.Thread(target = add_profit, args = ())
  thread2 = threading.Thread(target = pay_bill, args = ())
  # Starting the threads  
  thread1.start() 
  thread2.start() 
  # Waiting for both the threads to finish executing 
  thread1.join()
  thread2.join()
  # Displaying the final value of the deposit
  print(deposit)

  55 ngay lập tức.

• Nếu bộ đếm bên trong bằng không trên mục nhập, hãy chặn cho đến khi đánh thức bằng một cuộc gọi đến

  # Importing the threading module
  import threading 
  # Declraing a lock
  lock = threading.Lock()
  deposit = 100
  # Function to add profit to the deposit
  def add_profit(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit + 10
          lock.release()
  # Function to deduct money from the deposit
  def pay_bill(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit - 10
          lock.release()
  # Creating threads
  thread1 = threading.Thread(target = add_profit, args = ())
  thread2 = threading.Thread(target = pay_bill, args = ())
  # Starting the threads  
  thread1.start() 
  thread2.start() 
  # Waiting for both the threads to finish executing 
  thread1.join()
  thread2.join()
  # Displaying the final value of the deposit
  print(deposit)

  71. Sau khi đánh thức (và bộ đếm lớn hơn 0), giảm bộ đếm xuống 1 và trả về

  # Importing the threading module
  import threading 
  # Declraing a lock
  lock = threading.Lock()
  deposit = 100
  # Function to add profit to the deposit
  def add_profit(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit + 10
          lock.release()
  # Function to deduct money from the deposit
  def pay_bill(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit - 10
          lock.release()
  # Creating threads
  thread1 = threading.Thread(target = add_profit, args = ())
  thread2 = threading.Thread(target = pay_bill, args = ())
  # Starting the threads  
  thread1.start() 
  thread2.start() 
  # Waiting for both the threads to finish executing 
  thread1.join()
  thread2.join()
  # Displaying the final value of the deposit
  print(deposit)

  55. Chính xác một chủ đề sẽ bị đánh thức bởi mỗi cuộc gọi đến

  # Importing the threading module
  import threading 
  # Declraing a lock
  lock = threading.Lock()
  deposit = 100
  # Function to add profit to the deposit
  def add_profit(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit + 10
          lock.release()
  # Function to deduct money from the deposit
  def pay_bill(): 
      global deposit
      for i in range(100000):
          lock.acquire()
          deposit = deposit - 10
          lock.release()
  # Creating threads
  thread1 = threading.Thread(target = add_profit, args = ())
  thread2 = threading.Thread(target = pay_bill, args = ())
  # Starting the threads  
  thread1.start() 
  thread2.start() 
  # Waiting for both the threads to finish executing 
  thread1.join()
  thread2.join()
  # Displaying the final value of the deposit
  print(deposit)

  71. Thứ tự mà các chủ đề bị đánh thức không nên dựa vào.

Khi được gọi bằng chặn được đặt thành

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.2: Tham số thời gian chờ là mới.The timeout parameter is new.

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

Đã thay đổi trong phiên bản 3.9: Đã thêm tham số N để phát hành nhiều luồng chờ cùng một lúc.Added the n parameter to release multiple waiting threads at once.

Lớp thực hiện các đối tượng semaphore bị ràng buộc. Một semaphore bị ràng buộc 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ó,

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

maxconnections = 5
# ...
pool_sema = BoundedSemaphore(value=maxconnections)

with pool_sema:
    conn = connectdb()
    try:
        # ... use connection ...
    finally:
        conn.close()

Đố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ờ bên trong có thể được đặt thành đúng vớ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()

# 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()

mydata = threading.local()
mydata.x = 1

Lớp thực hiện các đối tượng sự kiện. Một sự kiện quản lý một lá cờ có thể được đặt thành True vớ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()

# 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()

mydata = threading.local()
mydata.x = 1

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

Trả về

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Phương phá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()

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

mydata = threading.local()
mydata.x = 1

Đặt lại cờ bên trong thành sai. Sau đó, các luồng gọi

mydata = threading.local()
mydata.x = 1

# 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()

Chặn cho đến khi cờ bên trong là đúng. Nếu cờ bên trong đúng khi nhập, hãy quay lại ngay lập tức. Mặt khác, 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()

Khi đối số thời gian chờ có mặt chứ không phải

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Đã thay đổi trong phiên bản 3.1: Trước đây, phương thức luôn được trả về

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

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

Lớp này đại diện cho một hành động chỉ nên được chạy sau một khoảng thời gian nhất định đã trôi qua - 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()

# 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()

Bộ định thời được bắt đầu, như với các chủ đề, bằng cách gọi phương thức

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

# 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()

Ví dụ:

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

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

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

# Consume an item
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

Thay đổi trong phiên bản 3.3: Thay đổi từ chức năng nhà máy sang một lớp.changed from a factory function to a class.

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

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

Mới trong phiên bản 3.2.

Lớp này cung cấp một nguyên thủy đồng bộ hóa đơn giản để sử dụng bởi một số lượng cố định các luồng cần phải đợi 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

mydata = threading.local()
mydata.x = 1

mydata = threading.local()
mydata.x = 1

Rào cản có thể được sử dụng lại bất kỳ số lần cho cùng một số lượng chủ đề.

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ủ:

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True:
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True:
        connection = make_connection()
        process_client_connection(connection)

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

mydata = threading.local()
mydata.x = 1

Chặn cho đến khi cờ bên trong là đúng. Nếu cờ bên trong đúng khi nhập, hãy quay lại ngay lập tức. Mặt khác, 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()

Giá trị trả về là một số nguyên trong phạm vi 0 đến các bên - 1, khác nhau cho mỗi 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 dọn phòng đặc biệt, ví dụ:

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Nếu một hành động được cung cấp cho hàm tạo, một trong các luồng sẽ gọi nó trước khi được phát hành. Nếu cuộc gọi này gây ra lỗi, rào cản đượ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()

Trả hàng rào cho trạng thái mặc định, trống. Bất kỳ chủ đề đang chờ đợi trên 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()

Lưu ý rằng 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 mà trạng thái không rõ. Nếu một rào cản bị phá vỡ, có thể tốt hơn là chỉ để nó và tạo ra một cái mới.

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

mydata = threading.local()
mydata.x = 1

# 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()

Có thể tốt hơn là chỉ cần tạo ra hàng rào 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 sẽ bị đánh giá cao.

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

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

Một boolean là

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

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

def hello():
    print("hello, world")

t = Timer(30.0, hello)
t.start()  # after 30 seconds, "hello, world" will be printed

# 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()

Sử dụng khóa, điều kiện và semaphores trong Tuyên bố mydata = threading.local() mydata.x = 1 18

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

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

mydata = threading.local()
mydata.x = 1

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

tương đương với:

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

Hiện tại,

# Importing the threading module
import threading 
# Declraing a lock
lock = threading.Lock()
deposit = 100
# Function to add profit to the deposit
def add_profit(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit + 10
        lock.release()
# Function to deduct money from the deposit
def pay_bill(): 
    global deposit
    for i in range(100000):
        lock.acquire()
        deposit = deposit - 10
        lock.release()
# Creating threads
thread1 = threading.Thread(target = add_profit, args = ())
thread2 = threading.Thread(target = pay_bill, args = ())
# Starting the threads  
thread1.start() 
thread2.start() 
# Waiting for both the threads to finish executing 
thread1.join()
thread2.join()
# Displaying the final value of the deposit
print(deposit)

mydata = threading.local()
mydata.x = 1

# 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()

# 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()

# 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()

mydata = threading.local()
mydata.x = 1