精华内容
下载资源
问答
  • python线程join

    2019-09-26 14:37:33
    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样 2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,...

    几个事实

    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样

    2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,不会等待子线程的执行结果。而且随着主线程退出,子线程也消亡。

    3 join方法的作用是阻塞,等待子线程结束,join方法有一个参数是timeout,即如果主线程等待timeout,子线程还没有结束,则主线程强制结束子线程。

    4 如果线程daemon属性为False, 则join里的timeout参数无效。主线程会一直等待子线程结束。

    5 如果线程daemon属性为True, 则join里的timeout参数是有效的, 主线程会等待timeout时间后,结束子线程。此处有一个坑,即如果同时有N个子线程join(timeout),那么实际上主线程会等待的超时时间最长为 N * timeout, 因为每个子线程的超时开始时刻是上一个子线程超时结束的时刻。

    测试代码

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:857662006 寻找有志同道合的小伙伴,互帮互助,
    群里还有不错的视频学习教程和PDF电子书!
    '''
    import threading,time
    
    def func():
        print "start thread time: ",time.strftime('%H:%M:%S')
        time.sleep(3)
        print "stop thread time: ",time.strftime('%H:%M:%S')
    
    thread_list = []
    for i in range(3):
        t1 = threading.Thread(target=func)
        #t1.setDaemon(True)
    
        thread_list.append(t1)
    
    for r in thread_list:
        r.start()
    
    for t in thread_list:
        #t.join(1)
        t.join()
    print "stop main thread"
    
    ###子线程如果设置了t.join(timeout),则根据timeout的不同,结果会不同,前提是设置了setDaemon(True),否则join的timeout是没效的
    
    #设置了setDaemon(True),但是没设置t.join()的运行结果:
    #start thread time:  17:25:29
    #start thread time:  17:25:29
    #start thread time:  17:25:29
    #stop main thread
    
    #加了t1.setDaemon(True),并且设置了超时时间t.join(1)的运行结果:
    #start thread time:  17:12:24
    #start thread time:  17:12:24
    #start thread time:  17:12:24
    #stop main thread
    
    #没加t1.setDaemon(True),并且设置了超时时间t.join(1)的运行结果,不过因为setDaemon的参数不是True所以就算设置了超时时间也没用:
    #start thread time:  17:13:28
    #start thread time:  17:13:28
    #start thread time:  17:13:28
    #stop main thread
    #stop thread time:   17:13:31
    #stop thread time:   17:13:31
    #stop thread time:   17:13:31
    
    #没加t1.setDaemon(True),但是设置了t.join(),没有超时时间的阻塞的运行结果:
    #start thread time:  17:16:12
    #start thread time:  17:16:12
    #start thread time:  17:16:12
    #stop thread time:   17:16:15
    #stop thread time:   17:16:15
    #stop thread time:   17:16:15
    #stop main thread 
    
    #即没有设置setDaemon(True),也没有设置join()的运行结果:
    #start thread time:  17:22:25
    #start thread time:  17:22:25
    #start thread time:  17:22:25
    #stop main thread
    #stop thread time:   17:22:28
    #stop thread time:   17:22:28
    #stop thread time:   17:22:28
    

    总结:

    如果想让子进程正常的运行结束(子进程中所有的内容都运行了),则如果设置join(timeout)的话,前提是设置setDaemon(True),且setDaemon的参数为True,且join(timeout)的超时时间必须大于子进程执行所需的时间,不然没等子进程运行结束就超时退出了.或者直接设置join()不带超时时间,也不用设置setDaemon(True)了

    展开全文
  • python 线程join Python Thread.join()方法 (Python Thread.join() Method) Thread.join() method is an inbuilt method of the Thread class of the threading module in Python. Whenever this method is called ...

    python 线程join

    Python Thread.join()方法 (Python Thread.join() Method)

    Thread.join() method is an inbuilt method of the Thread class of the threading module in Python. Whenever this method is called for any Thread object, it blocks the calling thread till the time the thread whose join() method is called terminates, either normally or through an unhandled exception.

    Thread.join()方法是Python中线程模块的Thread类的内置方法。 每当为任何Thread对象调用此方法时,它都会阻塞调用线程,直到调用join()方法的线程正常终止或通过未处理的异常终止为止。

    Module:

    模块:

        from threading import Thread
    
    

    Syntax:

    句法:

        join(timeout=None)
    
    

    Parameter(s):

    参数:

    • timeout: It is an optional parameter, which specifies a timeout for the operation in seconds. it should be a floating-point number. When a timeout argument is missing, the operation will block until the thread terminates.

      timeout :这是一个可选参数,以秒为单位指定操作的超时时间。 它应该是一个浮点数。 当缺少超时参数时,该操作将阻塞直到线程终止。

    Return value:

    返回值:

    The return type of this method is <class 'NoneType'>, it returns nothing.

    此方法的返回类型为<class'NoneType'> ,它什么也不返回。

    Example:

    例:

    # Python program to explain the
    # use of join() method in Thread class
    
    import time
    import threading
    
    def thread_1(i):
        time.sleep(2)
        print('Value by Thread 1:', i)
    
    def thread_2(i):
        time.sleep(5)
        print('Value by Thread 2:', i)
    
    def thread_3(i):
        print('Value by Thread 3:', i)    
    
        
    # Creating three sample threads 
    thread1 = threading.Thread(target=thread_1, args=(1,))
    thread2 = threading.Thread(target=thread_2, args=(2,))
    thread3 = threading.Thread(target=thread_3, args=(3,))
    
    # Running three thread object
    thread1.start()
    thread1.join()
    thread2.start()
    thread2.join()
    thread3.start()
    thread3.join()
    
    print()
    # Creating another 3 threads
    thread4 = threading.Thread(target=thread_1, args=(1,))
    thread5 = threading.Thread(target=thread_2, args=(2,))
    thread6 = threading.Thread(target=thread_3, args=(3,))
    
    thread4.start()
    thread5.start()
    thread6.start()
    thread4.join()
    thread5.join()
    thread6.join()
    
    

    Output

    输出量

    Value by Thread 1: 1
    Value by Thread 2: 2
    Value by Thread 3: 3
    
    Value by Thread 3: 3
    Value by Thread 1: 1
    Value by Thread 2: 2
    
    

    In the initial three Thread objects, we first created a thread and waited for it to execute and then joined to the main thread. So they are printed in the same order as called.

    在最初的三个Thread对象中,我们首先创建一个线程,等待它执行,然后加入主线程。 因此它们以与调用相同的顺序打印。

    In the next three Thread objects, they are running simultaneously, so they get printed according to the time they should be executed,

    在接下来的三个Thread对象中,它们同时运行,因此根据执行时间将它们打印出来,

        time(thread3)<time(thread2)<time(thread1)
    
    

    Example:

    例:

    # Python program to explain the
    # use of join() method in Thread class 
    # with timeout parameter defined
    
    import time
    import threading
    
    def thread_1(i):
        time.sleep(2)
        print('Value by Thread 1:', i)
    
    def thread_2(i):
        time.sleep(5)
        print('Value by Thread 2:', i)
        
    # Creating three sample threads 
    thread1 = threading.Thread(target=thread_1, args=(1,))
    thread2 = threading.Thread(target=thread_2, args=(2,))
    
    # Running three thread object
    thread1.start()
    thread1.join(timeout=5)
    thread2.start()
    thread2.join()
    
    

    Output

    输出量

    Value by Thread 1: 1
    Value by Thread 2: 2
    
    
    

    翻译自: https://www.includehelp.com/python/thread-join-method-with-example.aspx

    python 线程join

    展开全文
  • 主要介绍了python线程join方法原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • python线程join方法

    2019-04-02 10:36:00
    Python线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例: 首先需要明确几个概念: 知识点一:当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,主线...

    转载:http://www.cnblogs.com/cnkai/p/7504980.html

    Python多线程与多进程中join()方法的效果是相同的。

    下面仅以多线程为例:

    首先需要明确几个概念:

    知识点一:
    当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,主线程会创建多个子线程,在python中,默认情况下(其实就是setDaemon(False)),主线程执行完自己的任务以后,就退出了,此时子线程会继续执行自己的任务,直到自己的任务结束,例子见下面一。

    知识点二:
    当我们使用setDaemon(True)方法,设置子线程为守护线程时,主线程一旦执行结束,则全部线程全部被终止执行,可能出现的情况就是,子线程的任务还没有完全执行结束,就被迫停止,例子见下面二。

    知识点三:
    此时join的作用就凸显出来了,join所完成的工作就是线程同步,即主线程任务结束之后,进入阻塞状态,一直等待其他的子线程执行结束之后,主线程在终止,例子见下面三。

    知识点四:
    join有一个timeout参数:

    1. 当设置守护线程时,含义是主线程对于子线程等待timeout的时间将会杀死该子线程,最后退出程序。所以说,如果有10个子线程,全部的等待时间就是每个timeout的累加和。简单的来说,就是给每个子线程一个timeout的时间,让他去执行,时间一到,不管任务有没有完成,直接杀死。
    2. 没有设置守护线程时,主线程将会等待timeout的累加和这样的一段时间,时间一到,主线程结束,但是并没有杀死子线程,子线程依然可以继续执行,直到子线程全部结束,程序退出。

    一:Python多线程的默认情况

    import threading
    import time
    
    def run():
        time.sleep(2)
        print('当前线程的名字是: ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
    
        start_time = time.time()
    
        print('这是主线程:', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
    
        for t in thread_list:
            t.start()
    
        print('主线程结束!' , threading.current_thread().name)
        print('一共用时:', time.time()-start_time)

    其执行结果如下

    关键点:

    1. 我们的计时是对主线程计时,主线程结束,计时随之结束,打印出主线程的用时。
    2. 主线程的任务完成之后,主线程随之结束,子线程继续执行自己的任务,直到全部的子线程的任务全部结束,程序结束。

    二:设置守护线程

    import threading
    import time
    
    def run():
    
        time.sleep(2)
        print('当前线程的名字是: ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
    
        start_time = time.time()
    
        print('这是主线程:', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
    
        for t in thread_list:
            t.setDaemon(True)
            t.start()
    
        print('主线程结束了!' , threading.current_thread().name)
        print('一共用时:', time.time()-start_time)

    其执行结果如下,注意请确保setDaemon()在start()之前。

    关键点:

    1. 非常明显的看到,主线程结束以后,子线程还没有来得及执行,整个程序就退出了。

    三:join的作用

    import threading
    import time
    
    def run():
    
        time.sleep(2)
        print('当前线程的名字是: ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
    
        start_time = time.time()
    
        print('这是主线程:', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
    
        for t in thread_list:
            t.setDaemon(True)
            t.start()
    
        for t in thread_list:
            t.join()
    
        print('主线程结束了!' , threading.current_thread().name)
        print('一共用时:', time.time()-start_time)

    其执行结果如下:

    关键点:

      1. 可以看到,主线程一直等待全部的子线程结束之后,主线程自身才结束,程序退出。

    转载于:https://www.cnblogs.com/wisir/p/10641101.html

    展开全文
  • python线程join,同步

    2020-10-09 10:11:30
    线程join()的用法 含代码  join()所完成的工作就是线程同步,即主线程任务结束之后,进入阻塞状态,一直等待其他的子线程执行结束之后,主线程在终止。  设置守护线程时,主线程一旦执行结束,则将杀死子线程...

    多线程中join()的用法

    含代码
     join()所完成的工作就是线程同步,即主线程任务结束之后,进入阻塞状态,一直等待其他的子线程执行结束之后,主线程在终止。
     设置守护线程时,主线程一旦执行结束,则将杀死子线程。不设置时,主线程结束,子线程依然可以继续执行。

    global关键字

     若想在函数内部对函数外的变量进行操作,就需要在函数内部声明其为global。

    线程同步

     启动一个线程就是把一个函数传入并创建Thread实例,然后调用start()开始执行:
     多线程中,所有变量都由所有线程共享,所以,任何一个变量都可以被任何一个线程修改,因此,线程之间共享数据最大的危险在于多个线程同时改一个变量。
     要给change_it()(函数)上一把锁,当某个线程开始执行change_it()时,我们说,该线程因为获得了锁,因此其他线程不能同时执行change_it(),只能等待,直到锁被释放后,获得该锁以后才能改。
     Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步,这两个对象都有 acquire 方法和 release 方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到 acquire 和 release 方法之间。
     由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁,导致多个线程全部挂起,既不能执行,也无法结束,只能靠操作系统强制终止。

    threading.Semaphore

     添加一个计数器功能,来限制一个时间点内的线程数量。 计数器不能小于0,当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。Semaphore用于控制进入数量的锁,控制同时进行的线程,内部是基于Condition来进行实现的
    https://www.cnblogs.com/callyblog/p/11147456.html

    threading.Timer

     创建的是一个线程,实现延迟一段时间重复调用函数。
    https://www.pynote.net/archives/1783

    Queue

    • 可以使用队列来实现线程间的同步,https://www.runoob.com/python3/python3-multithreading.html
    • 实现多线程间通讯,让各个线程共享数据,生产者把任务放到Queue中,供消费者(线程)去使用。https://blog.csdn.net/weixin_42625143/article/details/95064782
      https://blog.csdn.net/iamaiearner/article/details/9363837

    queue中的put/get , put_nowait/get_nowait,https://blog.csdn.net/qq_32446743/article/details/80067013

    展开全文
  • python线程join的作用

    2018-09-30 19:51:08
    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样 2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,...
  • Python线程join和setDaemon

    2020-12-15 16:05:04
    看一下线程的setDaemon()方法 import time import threading import ctypes import inspect def sayHello(): for i in range(10): print("hello") time.sleep(1) def _async_raise(tid, exctype): """raises ...
  • from threading import Thread # 导入 进程包 import time # 导入时间包 #============ 这里总共有 3个线程 两个自己设置的线程 一个是主线程 for i in range(5): print('主线程') def a(m): for i in ...
  • 基于上篇文章之后,我们了解了python程序执行流程,为什么要使用线程,以及什么情况下使用python线程,本文继此之后说说python多线程编程时,经常用到的join()和setDaemon()方法. join()方法 join ()方法:主线程(主程序)...
  • python线程join的正解

    万次阅读 2015-09-29 16:29:58
    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样  2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,...
  • python线程中 当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,主线程会创建多个子线程,在python中,默认情况下(其实就是setDaemon(False)),主线程执行完...
  • Python 线程join

    2016-06-29 22:27:14
    __author__ = 'Administrator' import threading import time def thrfun(x,y,thr=None):  if thr:  thr.join()  else:  time.sleep(2)  for i in range(x,y):  result=eval
  • 主要介绍了Python线程中对join方法的运用,join方法是阻塞线程的基本方法,需要的朋友可以参考下
  • python线程 join()

    2020-06-23 18:11:35
    python线程中,有join这一个方法,具体含义:其实就是阻塞当前调用它的线程,等待join执行完毕,当前线程继续执行。和java中的join函数的理解方式是一样的。 具体代码: import threading class T1(threading....
  • join([timeout]) 调用join函数会使得主线程阻塞,直到子线程运行结束或超时。参数timeout是一个数值类型,用来表示超时时间,如果未提供该参数,那么主调线程将一直阻塞直到子线程结束。 import threading import ...
  • 线程守候setDaemon 与线程同步join ** 一、setDaemon(False) ** 当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行的最小单位,当设置多线程时,主线程会创建多个子线程,在Python中,默认情况下就是...
  • python 线程

    2020-12-22 06:55:09
    线程4.join():等此线程执行完后,再执行其他线程或主线程5.GIL6.Python线程的工作过程7.线程锁,互斥锁8.死锁、递归锁三、Event类 python 线程 一、概念梳理 1.线程定义 线程是操作系统能够进行运算调度的最小...
  • Python线程join()用法

    2020-12-14 18:48:16
    Python线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例: 首先需要明确几个概念: 知识点一: 当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,...
  • Python线程join()方法

    千次阅读 2018-01-02 09:43:27
    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样 2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,...
  • 一 代码 import threading import time ...E:\python\python可以这样学\第13章 多线程与多进程编程\code>python SecondExample.py 15 16 17 18 19 5 6 7 8 9 True True
  • join 方法:阻塞线程 , 直到该线程执行完毕 因此 ,可以对join加一个超时操作 , join([timeout]),超过设置时间,就不再阻塞线程 jion加上还有一个后果就是, 子线程和主线程绑定在一起 , 直到子线程运行完毕,...
  • Python线程join()的用法

    千次阅读 2018-04-12 23:43:40
    Python 的多线程编程中,在实例代码中经常有 thread1.join()这样的代码。那么今天咱们用实际代码来解释一下 join 函数的作用。 join的原理就是依次检验线程池中的线程是否结束,没有结束就阻塞直到线程结束,...
  • join()方法:使用cameraup_thread.join()方法,保证这个线程执行完成后再执行下一个cameraup_thread线程。 而且join()方法不单会阻止
  • python 线程join方法的使用

    千次阅读 2014-03-12 15:42:01
    1、作用:让子线程插入主线程,直到子线程结束,可理解为在在join调用处把子线程的code move到了主线程,主线程接着下面的代码运行 2、触发条件:手动调用或主线程要退出时自动调用 3、example a) 主线程代码将要...
  • python线程中的join(转)

    2019-02-09 22:19:00
    Python线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例: 首先需要明确几个概念: 知识点一:当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,主线...
  • 参照这篇文章:python3对多线程join的理解 通常都是,线程join()后,顺序执行join()后面的代码,如下面的例子: def main(): print('---main begin----') t1 = threading.Thread(target=T1_job, name='T...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,105
精华内容 442
关键字:

python线程join

python 订阅