Hướng dẫn how do you join two threads in python? - làm thế nào để bạn tham gia hai chủ đề trong python?

Một ascii-ascii hơi vụng về để chứng minh cơ chế:

print 'Test one'
t.join()
print 'Test two'

________ gọi 24 nên được đặt theo dõi chủ đề chính, nhưng để thể hiện mối quan hệ chủ đề và giữ cho nó đơn giản nhất có thể, tôi chọn đặt nó vào chủ đề trẻ em thay thế.

without join:
+---+---+------------------                     main-thread
    |   |
    |   +...........                            child-thread(short)
    +..................................         child-thread(long)

with join
+---+---+------------------***********+###      main-thread
    |   |                             |
    |   +...........join()            |         child-thread(short)
    +......................join()......         child-thread(long)

with join and daemon thread
+-+--+---+------------------***********+###     parent-thread
  |  |   |                             |
  |  |   +...........join()            |        child-thread(short)
  |  +......................join()......        child-thread(long)
  +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,     child-thread(long + daemonized)

'-' main-thread/parent-thread/main-program execution
'.' child-thread execution
'#' optional parent-thread execution after join()-blocked parent-thread could 
    continue
'*' main-thread 'sleeping' in join-method, waiting for child-thread to finish
',' daemonized thread - 'ignores' lifetime of other threads;
    terminates when main-programs exits; is normally meant for 
    join-independent tasks

Vì vậy, lý do bạn không thấy bất kỳ thay đổi nào là vì chủ đề chính của bạn không làm gì sau

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

Ví dụ, nếu bạn muốn tải xuống đồng thời một loạt các trang để kết hợp chúng vào một trang lớn, bạn có thể bắt đầu tải xuống đồng thời bằng cách sử dụng các chủ đề, nhưng cần phải đợi cho đến khi trang/chủ đề cuối cùng kết thúc trước khi bạn bắt đầu lắp ráp một trang duy nhất trong số nhiều. Đó là khi bạn sử dụng

print 'Test one'
t.join()
print 'Test two'

Yeaske

1.29314 Huy hiệu bạc21 Huy hiệu đồng14 silver badges21 bronze badges

Đã trả lời ngày 26 tháng 2 năm 2013 lúc 10:00Feb 26, 2013 at 10:00

Câu hỏi câu hỏiDon Question

10,9k5 Huy hiệu vàng33 Huy hiệu bạc51 Huy hiệu Đồng5 gold badges33 silver badges51 bronze badges

7

Trực tiếp từ các tài liệu

tham gia ([thời gian chờ]) đợi cho đến khi luồng chấm dứt. Điều này chặn luồng gọi cho đến khi luồng có phương thức tham gia () được gọi là chấm dứt - thông thường hoặc thông qua ngoại lệ chưa được xử lý - hoặc cho đến khi thời gian chờ tùy chọn xảy ra.

Điều này có nghĩa là chủ đề chính sinh ra

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

Tùy thuộc vào logic mà chương trình của bạn sử dụng, bạn có thể muốn đợi cho đến khi một chủ đề kết thúc trước khi chủ đề chính của bạn tiếp tục.

Cũng từ các tài liệu:

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.

Một ví dụ đơn giản, giả sử chúng ta có điều này:

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Kết thúc với:

print 'Test one'
t.join()
print 'Test two'

Điều này sẽ xuất hiện:

Test one
Test non-daemon
Test two

Ở đây, chủ đề chính chờ đợi chủ đề

print 'Test one'
t.join()
print 'Test two'

Test one
Test non-daemon
Test two

Ngoài ra, nếu chúng tôi có điều này:

print 'Test one'
print 'Test two'
t.join()

Chúng tôi sẽ nhận được đầu ra này:

Test one
Test two
Test non-daemon

Ở đây chúng tôi thực hiện công việc của chúng tôi trong chủ đề chính và sau đó chúng tôi chờ đợi chủ đề

print 'Test one'
t.join()
print 'Test two'

Test one
Test non-daemon
Test two

print 'Test one'
t.join()
print 'Test two'

Đã trả lời ngày 26 tháng 2 năm 2013 lúc 9:31Feb 26, 2013 at 9:31

1

Cảm ơn vì chủ đề này - nó cũng giúp tôi rất nhiều.

Tôi đã học được điều gì đó về .join () hôm nay.

Các luồng này chạy song song:

d.start()
t.start()
d.join()
t.join()

Và những lần chạy tuần tự này (không phải những gì tôi muốn):

d.start()
d.join()
t.start()
t.join()

Cụ thể, tôi đã cố gắng thông minh và ngăn nắp:

class Kiki(threading.Thread):
    def __init__(self, time):
        super(Kiki, self).__init__()
        self.time = time
        self.start()
        self.join()

Những công việc này! Nhưng nó chạy tuần tự. Tôi có thể đặt bản thân.start () vào __ init __, nhưng không phải là self.join (). Điều đó phải được thực hiện sau khi mỗi chủ đề đã được bắt đầu.

tham gia () là những gì khiến chủ đề chính chờ đợi chủ đề của bạn kết thúc. Nếu không, chủ đề của bạn tự chạy tất cả.

Vì vậy, một cách để nghĩ về tham gia () dưới dạng "giữ" trên luồng chính-nó sắp xếp luồng chủ đề của bạn và thực hiện tuần tự trong luồng chính, trước khi luồng chính có thể tiếp tục. Nó đảm bảo rằng chủ đề của bạn đã hoàn thành trước khi luồng chính di chuyển về phía trước. Lưu ý rằng điều này có nghĩa là ổn nếu chủ đề của bạn đã hoàn tất trước khi bạn gọi Jop () - luồng chính được phát hành ngay lập tức khi tham gia () được gọi.

Trên thực tế, bây giờ tôi chỉ xảy ra với tôi rằng chủ đề chính chờ đợi tại D.Join () cho đến khi Thread D kết thúc trước khi nó chuyển sang T.Join ().

Trên thực tế, rất rõ ràng, hãy xem xét mã này:

import threading
import time

class Kiki(threading.Thread):
    def __init__(self, time):
        super(Kiki, self).__init__()
        self.time = time
        self.start()

    def run(self):
        print self.time, " seconds start!"
        for i in range(0,self.time):
            time.sleep(1)
            print "1 sec of ", self.time
        print self.time, " seconds finished!"


t1 = Kiki(3)
t2 = Kiki(2)
t3 = Kiki(1)
t1.join()
print "t1.join() finished"
t2.join()
print "t2.join() finished"
t3.join()
print "t3.join() finished"

Nó tạo ra đầu ra này (lưu ý cách các câu lệnh in được luồn vào nhau.)

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

T1.join () đang giữ luồng chính. Tất cả ba luồng hoàn thành trước khi kết thúc T1.join () và luồng chính di chuyển lên để thực hiện bản in sau đó t2.join () sau đó in sau đó t3.join () sau đó in.

Sửa chữa chào mừng. Tôi cũng mới tham gia vào luồng.

.

Đã trả lời ngày 20 tháng 5 năm 2016 lúc 4:25May 20, 2016 at 4:25

Kiki Jewellkiki JewellKiki Jewell

7967 Huy hiệu bạc4 Huy hiệu đồng7 silver badges4 bronze badges

3

Với tham gia - thông dịch viên sẽ đợi cho đến khi quá trình của bạn được hoàn thành hoặc chấm dứtcompleted or terminated

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

không có tham gia - thông dịch viên sẽ không đợi cho đến khi quá trình bị chấm dứt,terminated,

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Đã trả lời ngày 6 tháng 3 năm 2019 lúc 5:04Mar 6, 2019 at 5:04

Trong python 3.x tham gia () được sử dụng để tham gia một luồng với luồng chính, tức là khi tham gia () được sử dụng cho một luồng cụ thể, luồng chính sẽ ngừng thực thi cho đến khi thực hiện hoàn tất luồng tham gia.

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Đã trả lời ngày 25 tháng 2 năm 2019 lúc 17:50Feb 25, 2019 at 17:50

Ví dụ này chứng minh hành động

Test one
Test non-daemon
Test two

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Ngoài:

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Đã trả lời ngày 22 tháng 1 năm 2019 lúc 9:41Jan 22, 2019 at 9:41

Khi tạo chức năng

Test one
Test non-daemon
Test two

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

Simhumileco

29.1k16 Huy hiệu vàng130 Huy hiệu bạc108 Huy hiệu đồng16 gold badges130 silver badges108 bronze badges

Đã trả lời ngày 9 tháng 9 năm 2013 lúc 14:39Sep 9, 2013 at 14:39

user1342336user1342336user1342336

9572 Huy hiệu vàng16 Huy hiệu bạc28 Huy hiệu đồng2 gold badges16 silver badges28 bronze badges

Có một vài lý do để luồng chính (hoặc bất kỳ luồng nào khác) tham gia các luồng khác

1. Một chủ đề có thể đã tạo hoặc giữ (khóa) một số tài nguyên. Chủ đề gọi tham gia có thể có thể xóa các tài nguyên thay mặt

2. tham gia () là một cuộc gọi chặn tự nhiên cho chuỗi gọi tham gia để tiếp tục sau khi luồng được gọi đã chấm dứt.

Nếu một chương trình Python không tham gia các chủ đề khác, trình thông dịch Python vẫn sẽ tham gia các chủ đề không phải là Daemon thay mặt.

Đã trả lời ngày 16 tháng 1 năm 2020 lúc 8:04Jan 16, 2020 at 8:04

Yoorghmyoorghmyoonghm

3.6041 Huy hiệu vàng 30 Huy hiệu bạc46 Huy hiệu Đồng1 gold badge30 silver badges46 bronze badges

Có vẻ như sự khác biệt giữa xử lý đồng bộ và không đồng bộ được hiểu sai ở đây.

Một chủ đề có nghĩa là để thực hiện một thủ thuật phụ, hầu hết các lần theo kiểu "song song" hoặc "đồng thời" (phụ thuộc vào việc thiết bị có đa bộ xử lý hay không). Nhưng, điểm nào về đồng thời? Đối với hầu hết các phần, đó là về việc cải thiện hiệu suất của một quy trình, bằng cách áp dụng ý tưởng "phân chia và chinh phục". Có một số luồng (quy trình phụ) thực hiện đồng thời "phần" của toàn bộ quá trình, và sau đó có bước "cuối cùng" trong đó tất cả các kết quả của quy trình phụ được kết hợp (tham gia; do đó phương thức "tham gia").

Tất nhiên, để đạt được mức tăng như vậy về hiệu quả, các phần được chia thành các luồng, phải là "loại trừ lẫn nhau" (nghĩa là, chúng không chia sẻ các giá trị được cập nhật ... - được gọi là tính toán song song là "quan trọng tiết diện" -- ). Nếu có ít nhất một giá trị được cập nhật bởi hai hoặc nhiều luồng, thì người ta phải đợi cái kia "hoàn thành" bản cập nhật của nó, nếu không thì có được kết quả không nhất quán (tức là hai người sở hữu tài khoản ngân hàng có ý định rút số tiền nhất định Tiền trong ATM ... nếu không có cơ chế thích hợp "khóa" hoặc "bảo vệ" số dư "biến đổi" trong cả hai thiết bị ATM, việc rút tiền sẽ hoàn toàn tăng giá trị cuối cùng của số dư, gây ra Rõ ràng vấn đề tài chính nghiêm trọng đối với chủ tài khoản).

Vì vậy, trở lại với mục đích của một chủ đề trong điện toán song song: có tất cả các luồng thực hiện phần riêng lẻ của chúng và sử dụng "tham gia" để biến chúng "quay lại" toàn cầu một.

Ví dụ? Một nhóm trong số họ, nhưng chúng ta hãy liệt kê một vài người được giải thích rõ ràng:

• Sự nhân ma trận: Có mỗi luồng nhân một vectơ của ma trận A với toàn bộ ma trận thứ hai B, để thu được một vectơ của ma trận C. Ở cuối, có tất cả các giao dịch kết quả được kết hợp với "hiển thị" (hiển thị) kết quả: Ma trận C. In Ví dụ này, mặc dù ma trận B được sử dụng bởi tất cả các luồng, không có giá trị của nó được cập nhật hoặc sửa đổi (chỉ đọc).

• Tổng kết, sản phẩm của một mảng các số lượng lớn (một mảng gồm hàng ngàn giá trị, cho dù là số nguyên hay float). Tạo các luồng để thực hiện các tổng/sản phẩm một phần (giả sử, nếu bạn phải tổng hợp các giá trị 10k, hãy tạo 5 luồng, mỗi chủ đề có giá trị 2K); Sau đó, với "Tham gia" khiến họ quay trở lại quy trình chính và tổng kết kết quả riêng lẻ của tất cả 5 luồng.

  Về mặt lý thuyết, quá trình này sẽ thực hiện 2000 + 5 bước (2000 đồng thời trong 5 luồng, cộng với tổng số 5 tổng số cuối cùng trong quy trình chính). Tuy nhiên, trong thực tế, 5 luồng mất bao lâu để thực hiện tổng số 2000 số của riêng mình là hoàn toàn thay đổi khi các yếu tố khác nhau tham gia ở đây (tốc độ bộ xử lý, luồng điện hoặc nếu đó là dịch vụ web, độ trễ mạng, v.v.) . Tuy nhiên, thời gian đầu tư của OT sẽ nằm trong "trường hợp xấu nhất", lượng thời gian mà chuỗi "chậm nhất", cộng với tổng số cuối cùng của 5 bước kết quả. Ngoài ra, trong thực tế, một chủ đề có nghĩa là làm 20% toàn bộ công việc, không thể sẽ mất nhiều thời gian hơn một quy trình tuần tự sẽ thực hiện 100% công việc (tất nhiên, nó cũng phụ thuộc vào kích thước của mẫu Để được xử lý ... Ưu điểm sẽ không giống nhau trên tổng giá trị 10K, so với tổng chỉ 10 giá trị với cùng 5 luồng ... đó không phải là thực hành, không đáng).

• Sắp xếp nhanh: Tất cả chúng ta đều biết nói chung làm thế nào nhanh chóng hoạt động. Tuy nhiên, có một cơ hội để cải thiện nó, nếu, giả sử, chúng tôi thực hiện nó trong hai luồng: một chủ đề thực hiện các số lẻ và một chủ đề làm cho các số thậm chí. Sau đó, thực hiện đệ quy và đến một lúc nào đó, nó tham gia kết quả của cả hai luồng và thực hiện một loại nhanh chóng cuối cùng theo kiểu sẽ không yêu cầu quá nhiều lần lặp lại vì các số sẽ được đặt hàng đủ sau khi hai chủ đề thực hiện công việc ban đầu. Đó là một serios đạt được hiệu suất với số lượng các mặt hàng khá lớn và không có thứ tự. Rất có thể là ba chủ đề có thể được sử dụng bằng cách thực hiện một số sắp xếp cho logic đằng sau nó, nhưng lợi ích của nó thực sự là tối thiểu và không đáng để được lập trình. Tuy nhiên, hai chủ đề có hiệu suất tốt (thời gian) tăng.

Vì vậy, việc sử dụng "tham gia" trong Python (hoặc nó tương đương với các ngôn ngữ "đồng thời" khác) có một ý nghĩa quan trọng; Nhưng phụ thuộc rất nhiều vào việc tìm hiểu những gì mà anh ấy muốn "paralellize" và cách anh ấy có kỹ năng trong việc chia thuật toán theo đúng bước để được song song so với những bước cần được giữ trong quy trình chính. Đó là một vấn đề của suy nghĩ "logic" hơn là một chương trình "chống lại một mẫu".

Đã trả lời ngày 26 tháng 9 lúc 21:25Sep 26 at 21:25

• print 'Test one'
  t.join()
  print 'Test two'
  

  3 chờ hoàn thành cả hai chủ đề không phải là daemon và daemon. waits for both non-daemon and daemon threads to be completed.

• Không có

  print 'Test one'
  t.join()
  print 'Test two'
  

  3, các luồng không phải là Daemon đang chạy và được hoàn thành với chủ đề chính đồng thời.

  print 'Test one'
  t.join()
  print 'Test two'
  

  3, non-daemon threads are running and are completed with the main thread concurrently.

• Không có

  print 'Test one'
  t.join()
  print 'Test two'
  

  3, các luồng daemon đang chạy với luồng chính đồng thời và khi hoàn thành luồng chính, các luồng daemon được thoát mà không hoàn thành nếu các luồng daemon vẫn đang chạy.

  print 'Test one'
  t.join()
  print 'Test two'
  

  3, daemon threads are running with the main thread concurrently and when the main thread is completed, the daemon threads are exited without completed if the daemon threads are still running.

Vì vậy, với

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
print 'Test two'
t.join()

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
print 'Test two'
t.join()

print 'Test one'
print 'Test two'
t.join()

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Hoặc, với

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
print 'Test two'
t.join()

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

print 'Test one'
t.join()
print 'Test two'

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Và, nếu không sử dụng

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
print 'Test two'
t.join()

def non_daemon():
    time.sleep(5)
    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

print 'Test one'
t.join()
print 'Test two'

Và, nếu không sử dụng

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
t.join()
print 'Test two'

print 'Test one'
print 'Test two'
t.join()

print 'Test one'
t.join()
print 'Test two'

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

Test one
Test two
Test non-daemon

print 'Test one'
t.join()
print 'Test two'

Đã trả lời ngày 27 tháng 10 lúc 7:10Oct 27 at 7:10

Kai - Kazuya Itokai - Kazuya ItoKai - Kazuya Ito

Huy hiệu vàng 11.8K672 Huy hiệu bạc91 Huy hiệu đồng6 gold badges72 silver badges91 bronze badges

"Việc sử dụng sử dụng tham gia () là gì?" bạn nói. Thực sự, đó là câu trả lời tương tự như "Việc sử dụng các tệp đóng là gì, vì Python và HĐH sẽ đóng tệp của tôi cho tôi khi chương trình của tôi thoát ra?".

Đó chỉ đơn giản là vấn đề lập trình tốt. Bạn nên tham gia () các luồng của bạn tại điểm trong mã mà luồng không nên chạy nữa, vì bạn phải tích cực đảm bảo luồng không chạy để can thiệp vào mã của riêng bạn hoặc bạn muốn hành xử chính xác trong một hệ thống lớn hơn.

Bạn có thể nói "Tôi không muốn mã của mình trì hoãn việc đưa ra câu trả lời" chỉ vì thời gian bổ sung mà tham gia () có thể yêu cầu. Điều này có thể hoàn toàn có giá trị trong một số kịch bản, nhưng bây giờ bạn cần tính đến rằng mã của bạn là "để Cruft xung quanh để Python và HĐH dọn dẹp". Nếu bạn làm điều này vì lý do hiệu suất, tôi rất khuyến khích bạn ghi lại hành vi đó. Điều này đặc biệt đúng nếu bạn đang xây dựng một thư viện/gói mà những người khác dự kiến ​​sẽ sử dụng.

Không có lý do gì để không tham gia (), ngoài lý do hiệu suất và tôi sẽ lập luận rằng mã của bạn không cần phải thực hiện tốt điều đó.

Đã trả lời ngày 19 tháng 12 năm 2013 lúc 23:05Dec 19, 2013 at 23:05

Chris Cogdonchris CogdonChris Cogdon

7.0635 Huy hiệu vàng37 Huy hiệu bạc 30 Huy hiệu Đồng5 gold badges37 silver badges30 bronze badges

5

Chúng ta có thể tham gia hai chủ đề không?

Chủ đề tham gia () trong luồng là gì?

Bạn có thể đa chủ đề trong Python?

Phương thức tham gia () nào?