Đa luồng Python trong lớp

Dữ liệu chủ đề cục bộ

Dữ liệu luồng cục bộ là dữ liệu có giá trị cụ thể theo luồng. Để quản lý dữ liệu cục bộ của luồng, chỉ cần tạo một thể hiện của (hoặc một lớp con) và lưu trữ các thuộc tính trên đó

________số 8_______

Các giá trị của cá thể 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 cục bộ luồng

Để 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

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

Đối tượng chủ đề

Lớp đại diện cho một hoạt động được chạy trong một luồng điều khiển riêng biệt. Có hai cách để xác định hoạt động. bằng cách chuyển một đối tượng có thể gọi được tới hàm tạo hoặc bằng cách ghi đè phương thức trong một lớp con. Không có phương thức nào khác (ngoại trừ hàm tạo) được ghi đè trong một lớp con. Nói cách khác, chỉ ghi đè

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

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 của luồng. Điều này gọi phương thức trong một luồng điều khiển riêng biệt

Khi hoạt động của chuỗi được bắt đầu, chuỗi được coi là 'còn sống'. Nó ngừng hoạt động khi phương thức của nó kết thúc - thông thường hoặc bằng cách đưa ra một ngoại lệ chưa được xử lý. Phương thức kiểm tra xem thread còn sống hay không

Các luồng khác có thể gọi phương thức của luồng. Điều này chặn luồng đang gọi cho đến khi luồng có phương thức được gọi kết thúc

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

Nếu phương thức đưa ra một ngoại lệ, được gọi để xử lý nó. Theo mặc định, bỏ qua âm thầm

Một luồng có thể được gắn cờ là một “luồng daemon”. Ý nghĩa của cờ này là toàn bộ chương trình Python sẽ thoát khi chỉ còn lại các luồng daemon. Giá trị ban đầu được kế thừa từ chuỗi tạo. Cờ có thể được đặt thông qua thuộc tính hoặc đối số hàm tạo daemon

Ghi chú

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

Có một đối tượng "chủ đề chính"; . Nó không phải là một chủ đề daemon

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

Hàm tạo này phải luôn được gọi với các đối số từ khóa. Đối số là

nhóm nên 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()

target là đối tượng có thể gọi được gọi theo phương thức. Mặc định 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()

tên là tên chủ đề. Theo mặc định, một tên duy nhất được tạo theo dạng “Chủ đề-N” trong đó N là một số thập phân nhỏ hoặc “Chủ đề-N (mục tiêu)” trong đó “mục tiêu” là _______14_______0 nếu đối số mục tiêu được chỉ định

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

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)

kwargs là một từ điển các đối số từ khóa cho lệnh gọi đích. Mặc định 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)

Nếu không phải là

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

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

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)

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

Đã thay đổi trong phiên bản 3. 3. Đã thêm đối số daemon.

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

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

Phương thức này sẽ tăng if được gọi nhiều lần trên cùng một đối tượng luồng

Phương thức đại diện cho hoạt động của luồng

Bạn có thể ghi đè phương thức này trong một lớp con. Phương thức tiêu chuẩn gọi đối tượng có thể gọi được truyền cho hàm tạo của đối tượng làm đối số đích, nếu có, với các đối số vị trí và từ khóa được lấy từ các đối số args và kwargs tương ứng

Sử dụng danh sách hoặc bộ dữ liệu làm đối số args được truyền cho có thể đạt được hiệu quả tương tự

Ví dụ

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

Chờ cho đến khi chủ đề kết thúc. Điều này chặn luồng đang gọi cho đến khi luồng có phương thức được gọi kết thúc - thông thường hoặc thông qua một ngoại lệ chưa được xử lý - hoặc cho đến khi hết thời gian chờ tùy chọn xảy ra

Khi đối số thời gian chờ xuất hiện và không phải là

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

# 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ố hết thời gian chờ không xuất hiện hoặc

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

tăng một nếu một nỗ lực được thực hiện để tham gia chủ đề hiện tại vì điều đó sẽ gây ra bế tắc. Đó cũng là một lỗi đối với một luồng trước khi nó được bắt đầu và cố gắng làm như vậy sẽ gây ra ngoại lệ tương tự

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

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

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

'Số nhận dạng chủ đề' của chủ đề này hoặc

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

ID chủ đề (

>>> from threading import Thread
>>> t = Thread(target=print, args=[1])
>>> t.run()
1
>>> t = Thread(target=print, args=(1,))
>>> t.run()
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()

Ghi chú

Tương tự như ID quy trình, ID luồng chỉ hợp lệ (được đảm bảo là duy nhất trên toàn hệ thống) từ khi luồng được tạo cho đến khi luồng kết thúc

Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX, DragonFlyBSD

Mới trong phiên bản 3. 8

Trả về xem thread còn sống hay không

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

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

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

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

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

Toàn bộ chương trình Python thoát khi không còn luồng không phải daemon nào còn sống

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

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

Khóa đối tượng

Khóa nguyên thủy là nguyên thủy đồng bộ hóa không thuộc sở hữu của một luồng cụ thể khi bị khóa. Trong Python, nó hiện là nguyên mẫu đồng bộ hóa mức thấp nhất hiện có, được triển khai trực tiếp bởi mô-đun mở rộng

Khóa nguyên thủy ở một trong hai trạng thái, "đã khóa" hoặc "đã mở khóa". Nó được tạo ở trạng thái mở khóa. Nó có hai phương pháp cơ bản, và. Khi trạng thái được mở khóa, thay đổi trạng thái thành bị khóa và quay lại ngay lập tức. Khi trạng thái bị khóa, chặn cho đến khi một cuộc gọi đến trong một chuỗi khác thay đổi trạng thái đó thành mở khóa, sau đó cuộc gọi đặt lại thành bị khóa và quay lại. Phương thức chỉ nên được gọi ở trạng thái bị khóa; . Nếu một nỗ lực được thực hiện để giải phóng một khóa đã được mở khóa, một điểm sẽ được nâng lên

Ổ khóa cũng hỗ trợ

Khi có nhiều hơn một luồng bị chặn trong khi chờ trạng thái chuyển sang mở khóa, chỉ một luồng tiếp tục khi một cuộc gọi đặt lại trạng thái thành mở khóa;

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

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

Lưu ý rằng

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

Nhận khóa, chặn hoặc không chặn

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

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

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

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

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

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

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

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

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

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

Giá trị trả về là

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

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

Đã thay đổi trong phiên bản 3. 2. Tham số thời gian chờ là mới.

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

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

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

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

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

Trả lại

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

RLock đối tượng

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

Để khóa khóa, một luồng gọi phương thức của nó; . Để mở khóa, một luồng gọi phương thức của nó. / các cặp cuộc gọi có thể được lồng vào nhau;

Khóa Reentrant cũng hỗ trợ

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

Lưu ý rằng

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

Nhận khóa, chặn hoặc không chặn

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

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

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

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

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

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

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

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

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

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

Đã thay đổi trong phiên bản 3. 2. Tham số thời gian chờ là mới.

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

Chỉ gọi phương thức này khi luồng gọi sở hữu khóa. A được nâng lên nếu phương thức này được gọi khi khóa được mở khóa

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

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

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

Một biến điều kiện tuân theo. sử dụng câu lệnh

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

Các phương thức khác phải được gọi với khóa liên quan được giữ. Phương thức giải phóng khóa, sau đó chặn cho đến khi một luồng khác đánh thức nó bằng cách gọi hoặc. Sau khi thức tỉnh, lấy lại khóa và quay trở lại. Cũng có thể chỉ định thời gian chờ

Phương thức đánh thức một trong các luồng đang chờ biến điều kiện, nếu có đang chờ. Phương thức đánh thức tất cả các luồng đang chờ biến điều kiện

Ghi chú. các phương thức và không giải phóng khóa;

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

Vòng lặp

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

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

Để chọn giữa và , hãy xem xét liệu một thay đổi trạng thái có thể thú vị đối với chỉ một hoặc một số luồng đang chờ hay không. e. g. trong một tình huống điển hình của nhà sản xuất-người tiêu dùng, việc thêm một mục vào bộ đệm chỉ cần đánh thức một luồng người tiêu dùng

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

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

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

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

Đợi cho đến khi được thông báo hoặc cho đến khi hết thời gian chờ. Nếu luồng đang gọi chưa nhận được khóa khi phương thức này được gọi, a sẽ được nâng lên

Phương pháp này giải phóng khóa cơ bản, sau đó chặn cho đến khi nó được đánh thức bởi một hoặc gọi cho cùng một biến điều kiện trong một luồng khác hoặc cho đến khi hết thời gian chờ tùy chọn xảy ra. Sau khi được đánh thức hoặc hết thời gian chờ, nó sẽ lấy lại khóa và quay lại

Khi đối số thời gian chờ xuất hiện và không phải là

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

Khi khóa bên dưới là một , thì nó không được giải phóng bằng phương thức của nó, vì điều này có thể không thực sự mở khóa khi nó được mua lại nhiều lần theo cách đệ quy. Thay vào đó, một giao diện bên trong của lớp được sử dụng, giao diện này thực sự mở khóa nó ngay cả khi nó đã được sử dụng đệ quy nhiều lần. Sau đó, một giao diện nội bộ khác được sử dụng để khôi phục mức đệ quy khi khóa được lấy lại

Giá trị trả về là

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

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

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

Phương thức tiện ích này có thể gọi lặp đi lặp lại cho đến khi vị từ được thỏa mãn hoặc cho đến khi hết thời gian chờ. Giá trị trả về là giá trị trả về cuối cùng của biến vị ngữ và sẽ đánh giá thành

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

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

while not predicate():
    cv.wait()

Do đó, các quy tắc tương tự được áp dụng như với. Khóa phải được giữ khi được gọi và được lấy lại khi trả lại. Vị từ được đánh giá với khóa được giữ

Mới trong phiên bản 3. 2

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

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

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

Ghi chú. một luồng được đánh thức không thực sự quay trở lại từ cuộc gọi của nó cho đến khi nó có thể lấy lại khóa. Vì không nhả khóa nên người gọi nó phải

Đánh thức tất cả các chủ đề đang chờ trong điều kiện này. Phương pháp này hoạt động như , nhưng đánh thức tất cả các chuỗi đang chờ thay vì một. Nếu luồng đang gọi chưa nhận được khóa khi phương thức này được gọi, a sẽ được nâng lên

Phương thức

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

Đối tượng Semaphore

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

Một semaphore quản lý một bộ đếm nội bộ được giảm dần theo mỗi cuộc gọi và tăng lên theo mỗi cuộc gọi. Bộ đếm không bao giờ có thể xuống dưới 0;

Semaphores cũng hỗ trợ

Lớp này cài đặt các đối tượng semaphore. Một semaphore quản lý một bộ đếm nguyên tử biểu thị số lần gọi trừ đi số lần gọi, cộng với một giá trị ban đầu. Phương thức chặn nếu cần thiết cho đến khi nó có thể quay lại mà không làm cho bộ đếm âm. Nếu không được cung cấp, giá trị mặc định là 1

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

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

Có được một semaphore

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

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

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

  07 ngay lập tức

• Nếu bộ đếm bên trong bằng 0 khi vào, hãy chặn cho đến khi được đánh thức bằng lệnh gọi đến. Sau khi được đánh thức (và bộ đếm lớn hơn 0), giảm bộ đếm đi 1 và trả về

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

  07. Chính xác một chủ đề sẽ được đánh thức bởi mỗi cuộc gọi đến. Không nên dựa vào thứ tự các luồng được đánh thức

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

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

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

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

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

Đã thay đổi trong phiên bản 3. 2. Tham số thời gian chờ là mới.

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

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

Lớp triển khai các đối tượng semaphore có giới hạn. Semaphore có giới hạn kiểm tra để đảm bảo giá trị hiện tại của nó không vượt quá giá trị ban đầu. Nếu nó làm, được nâng lên. Trong hầu hết các tình huống, đèn hiệu được sử dụng để bảo vệ các tài nguyên có dung lượng hạn chế. Nếu semaphore được phát hành quá nhiều lần, đó là dấu hiệu của một lỗi. Nếu không được cung cấp, giá trị mặc định là 1

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

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ờ nội bộ có thể được đặt thành true với phương thức và đặt lại thành false với phương thức. Phương pháp chặn cho đến khi cờ là đúng

Lớp thực hiện các đối tượng sự kiện. Một sự kiện quản lý cờ có thể được đặt thành true với phương thức và đặt lại thành false với phương thức. Phương pháp chặn cho đến khi cờ là đúng. Cờ ban đầu là sai

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

Trả về

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

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

Đặt cờ nội bộ thành true. Tất cả các chủ đề đang chờ nó trở thành sự thật được đánh thức. Các chủ đề gọi khi cờ là đúng sẽ hoàn toàn không bị chặn

Đặt lại cờ nội bộ thành sai. Sau đó, cuộc gọi chủ đề sẽ chặn cho đến khi được gọi để đặt lại cờ nội bộ thành đúng

Chặn cho đến khi cờ nội bộ là true. Nếu cờ nội bộ là đúng khi vào, hãy quay lại ngay lập tức. Mặt khác, chặn cho đến khi một chuỗi khác gọi để đặt cờ thành true hoặc cho đến khi hết thời gian chờ tùy chọn xảy ra

Khi đối số thời gian chờ xuất hiện và không phải là

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

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

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

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

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

Lớp này đại diện cho một hành động chỉ được chạy sau một khoảng thời gian nhất định - một bộ đếm thời gian. là một lớp con của và như vậy cũng có chức năng như một ví dụ về tạo chủ đề tùy chỉnh

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

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

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ố args và đối số từ khóa kwargs, sau khi khoảng thời gian giây trôi qua. Nếu đối số là

# Consume one item
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# Produce one item
with cv:
    make_an_item_available()
    cv.notify()

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

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

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

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

Mới trong phiên bản 3. 2

Lớp này cung cấp một nguyên mẫu đồng bộ hóa đơn giản để sử dụng bởi một số luồng cố định cần đợi lẫn nhau. Mỗi luồng cố gắng vượt qua rào cản bằng cách gọi phương thức và sẽ chặn cho đến khi tất cả các luồng đã thực hiện cuộc gọi của chúng. Tại thời điểm này, các luồng được giải phóng đồng thời

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

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

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

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

Giá trị trả về là một số nguyên trong phạm vi từ 0 đến bên – 1, khác nhau đối với 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 vệ sinh đặc biệt, e. g

i = barrier.wait()
if i == 0:
    # Only one thread needs to print this
    print("passed the barrier")

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

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

Phương pháp này có thể đưa ra một ngoại lệ nếu rào cản bị hỏng hoặc đặt lại trong khi một chuỗi đang chờ

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

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

Đặt rào cản vào trạng thái bị hỏng. Điều này khiến mọi cuộc gọi đang hoạt động hoặc trong tương lai không thành công với. Sử dụng ví dụ này nếu một trong các luồng cần hủy bỏ, để tránh làm bế tắc ứng dụng

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

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

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

Một giá trị boolean là

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

Ngoại lệ này, một lớp con của , được nâng lên khi đối tượng được đặt lại hoặc bị hỏng

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

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

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

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

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

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

Sử dụng đa luồng trong Python có tốt không?

Lớp nào có thể được sử dụng để triển khai luồng trong Python?

Vấn đề với đa luồng trong Python là gì?

Đa luồng có nhanh hơn trong Python không?