Какая польза от join () в потоке Python?

Я изучал потоки Python и наткнулся join() .

Автор сказал, что если поток находится в режиме демона, то мне нужно использовать его, join()чтобы поток мог завершить себя до завершения основного потока.

но я также видел его использование, t.join()хотя tне былоdaemon

пример кода это

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

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

d.start()
t.start()

d.join()
t.join()

я не знаю, что использовать, так t.join()как это не демон, и я не вижу изменений, даже если я удалю его

Несколько неуклюжий ascii-art для демонстрации механизма: join()предположительно вызывается основным потоком. Он также может быть вызван другим потоком, но излишне усложнит диаграмму.

join-calling должен быть помещен в дорожку основного потока, но чтобы выразить отношение потока и сделать его как можно более простым, я решил вместо этого поместить его в дочерний поток.

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

Поэтому причина, по которой вы не видите никаких изменений, заключается в том, что ваш основной поток ничего не делает после вашего join. Вы могли бы сказать, что joinэто (только) имеет отношение к потоку выполнения основного потока.

Например, если вы хотите одновременно загрузить несколько страниц, чтобы объединить их в одну большую страницу, вы можете начать одновременную загрузку с использованием потоков, но нужно дождаться окончания последней страницы / потока, прежде чем приступить к сборке одной страницы. из многих. Вот когда вы используете join().

Прямо из документов

объединение ([тайм-аут]) Дождитесь завершения потока. Это блокирует вызывающий поток до тех пор, пока поток, чей метод join () вызывается, не завершится - либо в обычном режиме, либо через необработанное исключение - либо пока не истечет необязательное время ожидания.

Это означает, что основная нить, которая порождает tи dожидает tзавершения, пока не закончится.

В зависимости от логики, которую использует ваша программа, вы можете дождаться завершения потока, прежде чем ваш основной поток продолжится.

Также из документов:

Поток может быть помечен как «поток демона». Значение этого флага заключается в том, что вся программа Python завершается, когда остаются только потоки демона.

Простой пример, скажем, у нас есть это:

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 non-daemon
Test two

Здесь главный поток явно ожидает завершения tпотока, пока он не вызовет printвторой раз.

В качестве альтернативы, если бы у нас было это:

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

Мы получим этот вывод:

Test one
Test two
Test non-daemon

Здесь мы делаем свою работу в главном потоке, а затем ждем окончания tпотока. В этом случае мы могли бы даже удалить явное соединение, t.join()и программа будет неявно ждать tзавершения.

Спасибо за эту ветку - она ​​мне тоже очень помогла.

Я кое-что узнал о .join () сегодня.

Эти потоки работают параллельно:

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

и они запускаются последовательно (не то, что я хотел):

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

В частности я пытался привести в порядок и привести в порядок

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

Это работает! Но это работает последовательно. Я могу поместить self.start () в __ init __, но не в self.join (). Это должно быть сделано после каждый поток был запущен.

join () - это то, что заставляет основной поток ждать завершения вашего потока. В противном случае ваш поток запускается сам по себе.

Таким образом, один из способов представить join () как «удержание» в основном потоке - это своего рода удаление потоков из вашего потока и последовательное выполнение в основном потоке, прежде чем основной поток сможет продолжить. Это гарантирует, что ваш поток завершен, прежде чем основной поток продвигается вперед. Обратите внимание, что это означает, что все в порядке, если ваш поток уже завершен до того, как вы вызовете join () - основной поток просто освобождается сразу после вызова join ().

На самом деле, мне только что пришло в голову, что основной поток ожидает d.join (), пока поток d не завершит свою работу, прежде чем перейдет к t.join ().

На самом деле, чтобы быть очень ясным, рассмотрим этот код:

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"

Он производит этот вывод (обратите внимание, как операторы печати встраиваются друг в друга.)

$ python test_thread.py
32   seconds start! seconds start!1

 seconds start!
1 sec of  1
 1 sec of 1  seconds finished!
 21 sec of
3
1 sec of  3
1 sec of  2
2  seconds finished!
1 sec of  3
3  seconds finished!
t1.join() finished
t2.join() finished
t3.join() finished
$ 

T1.join () поддерживает основной поток. Все три потока завершаются до того, как завершается t1.join (), и основной поток продолжает выполнение print, затем t2.join (), затем print, затем t3.join (), затем print.

Исправления приветствуются. Я также новичок в потоках.

(Примечание: в случае, если вам интересно, я пишу код для DrinkBot, и мне нужны потоки, чтобы запускать насосы ингредиентов одновременно, а не последовательно - меньше времени для ожидания каждого напитка.)

Метод join ()

блокирует вызывающий поток до тех пор, пока поток, чей метод join () вызывается, не завершится.

Источник: http://docs.python.org/2/library/threading.html

Простое понимание,

with join - интерпретатор будет ждать, пока ваш процесс не будет завершен или завершен

>>> from threading import Thread
>>> import time
>>> def sam():
...   print 'started'
...   time.sleep(10)
...   print 'waiting for 10sec'
... 
>>> t = Thread(target=sam)
>>> t.start()
started

>>> t.join() # with join interpreter will wait until your process get completed or terminated
done?   # this line printed after thread execution stopped i.e after 10sec
waiting for 10sec
>>> done?

без соединения - интерпретатор не будет ждать завершения процесса ,

>>> t = Thread(target=sam)
>>> t.start()
started
>>> print 'yes done' #without join interpreter wont wait until process get terminated
yes done
>>> waiting for 10sec

При создании join(t)функции как для потока, не являющегося демоном, так и для потока демона, основной поток (или основной процесс) должен подождать tнесколько секунд, а затем продолжить работу над своим собственным процессом. В течение tсекунд ожидания оба дочерних потока должны делать то, что они могут, например, распечатывать текст. Через tнесколько секунд, если поток, не являющийся демоном, все еще не завершил свою работу, и он все еще может завершить его после того, как основной процесс завершит свою работу, но для потока демона он просто пропустил свое окно возможностей. Тем не менее, он в конечном итоге умрет после выхода из программы Python. Пожалуйста, поправьте меня, если что-то не так.

В python 3.x join () используется для объединения потока с основным потоком, т.е. когда join () используется для определенного потока, основной поток прекращает выполнение до тех пор, пока не завершится выполнение присоединенного потока.

#1 - Without Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
print('Hey, I do not want to loiter!')
'''
Output without join()--> 
You are loitering!
Hey, I do not want to loiter!
You are not loitering anymore! #After 5 seconds --> This statement will be printed

'''
#2 - With Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
t1.join()
print('Hey, I do not want to loiter!')

'''
Output with join() -->
You are loitering!
You are not loitering anymore! #After 5 seconds --> This statement will be printed
Hey, I do not want to loiter! 

'''

Этот пример демонстрирует .join()действие:

import threading
import time

def threaded_worker():
    for r in range(10):
        print('Other: ', r)
        time.sleep(2)

thread_ = threading.Timer(1, threaded_worker)
thread_.daemon = True  # If the main thread kills, this thread will be killed too. 
thread_.start()

flag = True

for i in range(10):
    print('Main: ', i)
    time.sleep(2)
    if flag and i > 4:
        print(
            '''
            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.
            ''')
        thread_.join()
        flag = False

Вне:

Main:  0
Other:  0
Main:  1
Other:  1
Main:  2
Other:  2
Main:  3
Other:  3
Main:  4
Other:  4
Main:  5
Other:  5

            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.

Other:  6
Other:  7
Other:  8
Other:  9
Main:  6
Main:  7
Main:  8
Main:  9

Есть несколько причин для основного потока (или любого другого потока) присоединиться к другим потокам

1. Поток мог создать или удерживать (блокировать) некоторые ресурсы. Поток, выполняющий соединение, может очистить ресурсы от своего имени.

2. join () - это естественный блокирующий вызов для потока, вызывающего соединение, для продолжения после завершения вызываемого потока.

Если программа python не присоединяется к другим потокам, интерпретатор python по-прежнему присоединяется к потокам, не являющимся демонами, от своего имени.

"Какая польза от использования join ()?" ты говоришь. Действительно, это тот же ответ, что и «зачем использовать закрытие файлов, так как python и ОС закроют мой файл для меня, когда выйдет моя программа?».

Это просто вопрос хорошего программирования. Вы должны присоединиться () к вашим потокам в той точке кода, которую поток не должен больше должен работать, либо потому, что вы должны убедиться, что поток не работает, чтобы мешать вашему собственному коду, либо что вы хотите правильно вести себя в большая система.

Вы можете сказать: «Я не хочу, чтобы мой код задерживал предоставление ответа» только из-за дополнительного времени, которое может потребоваться join (). Это может быть совершенно справедливо в некоторых сценариях, но теперь вы должны принять во внимание, что ваш код "оставляет желать лучшего для python и операционной системы для очистки". Если вы делаете это по причинам производительности, я настоятельно рекомендую вам задокументировать это поведение. Это особенно верно, если вы создаете библиотеку / пакет, который, как ожидается, будут использовать другие.

Там нет причин , чтобы не присоединиться (), кроме соображений производительности, и я бы сказал , что ваш код не должен выполнять эту скважину.