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

    2020-06-23 18:11:35
    python多线程中,有join这一个方法,具体含义:其实就是阻塞当前调用它的线程,等待join执行完毕,当前线程继续执行。和java中的join函数的理解方式是一样的。 具体代码: import threading class T1(threading....

    join()

    python多线程中,有join这一个方法,具体含义:其实就是阻塞当前调用它的线程,等待join执行完毕,当前线程继续执行。和java中的join函数的理解方式是一样的。

    具体代码:

    
    import threading
    
    class T1(threading.Thread):
        i = 0
        def run(self):
            while self.i < 100000:
                self.i += 1
                print("T1---->" + str(self.i))
    
    class T2(threading.Thread):
        def run(self):
        	while True:
                print("I am T2")
    
    
    
    
    if __name__ == '__main__':
    	# 开启第一个线程
        t1 = T1()
        t1.start()
        # 开启第二个线程
        t2 = T2()
        t2.start()
        # 将第一个线程join()进去
        t1.join()
        
        while True:
            print("I am Main")
    

    这段代码执行之后,顺着程序来看:创建两个线程并开启之后,并将第一个线程join(),那么Main进程就会进入一种等待状态,但此时线程2并不会受到影响。等线程1结束之后,Main继续执行,线程2也在执行,那么打印结果就会交替输出。

    展开全文
  • Python多线程join()的用法

    千次阅读 2018-04-12 23:43:40
    Python多线程编程中,在实例代码中经常有 thread1.join()这样的代码。那么今天咱们用实际代码来解释一下 join 函数的作用。 join的原理就是依次检验线程池中的线程是否结束,没有结束就阻塞直到线程结束,...

    在 Python 的多线程编程中,在实例代码中经常有 thread1.join()这样的代码。那么今天咱们用实际代码来解释一下 join 函数的作用。

     

    join的原理就是依次检验线程池中的线程是否结束,没有结束就阻塞直到线程结束,如果结束则跳转执行下一个线程的join函数。

     

    先看看这个:

    1. 阻塞主进程,专注于执行多线程中的程序。

    # 测试多线程中join的功能
    import threading, time
    def doWaiting():
        print('thread %s is running345...' % threading.current_thread().name)
        print ('start waiting1: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(10)
        print ('stop waiting1: ' + time.strftime('%H:%M:%S') + "\n")
    def doWaiting1():
        print('thread %s is running567' % threading.current_thread().name)
        print( 'start waiting2: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(8)
        print ('stop waiting2: ', time.strftime('%H:%M:%S') + "\n" )
    print('thread %s is running123...' % threading.current_thread().name)
    tsk = []
    thread1 = threading.Thread(target = doWaiting,name='thread1')
    thread1.start()
    thread1.join()
    print('thread %s is running123...' % threading.current_thread().name)
    tsk.append(thread1)
    thread2 = threading.Thread(target = doWaiting1,name='thread2')
    thread2.start()
    # thread2.join()
    tsk.append(thread2)
    print ('start join: ' + time.strftime('%H:%M:%S') + "\n"   )
    # for tt in tsk:
    #     tt.start()
    #     tt.join()
    print ('end join: ' + time.strftime('%H:%M:%S') + "\n")
    结果
    thread MainThread is running123...
    thread thread1 is running345...
    start waiting1: 23:49:23
    
    stop waiting1: 23:49:33
    
    thread MainThread is running123...
    thread thread2 is running567
    start waiting2: 23:49:33
    
    start join: 23:49:33
    
    end join: 23:49:33
    
    stop waiting2:  23:49:41

    2. 多线程多join的情况下,依次执行各线程的join方法,前头一个结束了才能执行后面一个。

    3. 无参数,则等待到该线程结束,才开始执行下一个线程的join。

    import threading, time
    def doWaiting():
        print ('start waiting1: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(10)
        print ('stop waiting1: ' + time.strftime('%H:%M:%S') + "\n")
    def doWaiting1():
        print( 'start waiting2: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(8)
        print ('stop waiting2: ', time.strftime('%H:%M:%S') + "\n" )
    tsk = []
    thread1 = threading.Thread(target = doWaiting)
    thread1.start()
    thread1.join()
    tsk.append(thread1)
    thread2 = threading.Thread(target = doWaiting1)
    thread2.start()
    tsk.append(thread2)
    print ('start join: ' + time.strftime('%H:%M:%S') + "\n"   )
    # for tt in tsk:
    #     tt.join()
    print ('end join: ' + time.strftime('%H:%M:%S') + "\n")
    结果
    start waiting1: 23:31:50
    
    stop waiting1: 23:32:00
    
    start waiting2: 23:32:00
    
    start join: 23:32:00

    4. 参数timeout为线程的阻塞时间,如 timeout=6 就是执行这个线程6s 以后,就不管他了,继续执行下面的代码。

    import threading, time
    def doWaiting():
        print ('start waiting1: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(10)
        print ('stop waiting1: ' + time.strftime('%H:%M:%S') + "\n")
    def doWaiting1():
        print( 'start waiting2: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(8)
        print ('stop waiting2: ', time.strftime('%H:%M:%S') + "\n" )
    tsk = []
    thread1 = threading.Thread(target = doWaiting)
    thread1.start()
    thread1.join(6)
    tsk.append(thread1)
    thread2 = threading.Thread(target = doWaiting1)
    thread2.start()
    tsk.append(thread2)
    print ('start join: ' + time.strftime('%H:%M:%S') + "\n"   )
    # for tt in tsk:
    #     tt.join()
    print ('end join: ' + time.strftime('%H:%M:%S') + "\n")

    结果

    start waiting1: 23:30:56
    
    start waiting2: 23:31:02
    
    start join: 23:31:02
    
    end join: 23:31:02
    

    注意thread.start(),thread.join()要连着用才能体现出join()阻塞线程的作用

    # 测试多线程中join的功能
    import threading, time
    def doWaiting():
        print ('start waiting1: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(10)
        print ('stop waiting1: ' + time.strftime('%H:%M:%S') + "\n")
    def doWaiting1():
        print( 'start waiting2: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(8)
        print ('stop waiting2: ', time.strftime('%H:%M:%S') + "\n" )
    tsk = []
    thread1 = threading.Thread(target = doWaiting)
    thread1.start()
    # thread1.join()
    tsk.append(thread1)
    thread2 = threading.Thread(target = doWaiting1)
    thread2.start()
    tsk.append(thread2)
    print ('start join: ' + time.strftime('%H:%M:%S') + "\n"   )
    for tt in tsk:
        # tt.start()
        tt.join()
    print ('end join: ' + time.strftime('%H:%M:%S') + "\n")
    start waiting1: 23:39:12
    
    start waiting2: 23:39:12
    start join: 23:39:12
    
    
    stop waiting2:  23:39:20
    
    stop waiting1: 23:39:22
    
    end join: 23:39:22

    本来我们想的是thread1完全执行完了,再执行thread2,但事实是因为thread2 sleep了8秒更早结束了,然后thread1 sleep了10才结束

    再看看连着的

    # 测试多线程中join的功能
    import threading, time
    def doWaiting():
        print ('start waiting1: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(10)
        print ('stop waiting1: ' + time.strftime('%H:%M:%S') + "\n")
    def doWaiting1():
        print( 'start waiting2: ' + time.strftime('%H:%M:%S') + "\n" )
        time.sleep(8)
        print ('stop waiting2: ', time.strftime('%H:%M:%S') + "\n" )
    tsk = []
    thread1 = threading.Thread(target = doWaiting)
    # thread1.start()
    # thread1.join()
    tsk.append(thread1)
    thread2 = threading.Thread(target = doWaiting1)
    # thread2.start()
    tsk.append(thread2)
    print ('start join: ' + time.strftime('%H:%M:%S') + "\n"   )
    for tt in tsk:
        tt.start()
        tt.join()
    print ('end join: ' + time.strftime('%H:%M:%S') + "\n")
    结果
    start join: 23:42:34
    
    start waiting1: 23:42:34
    
    stop waiting1: 23:42:44
    
    start waiting2: 23:42:44
    
    stop waiting2:  23:42:52
    
    end join: 23:42:52



    展开全文
  • 今天写一个小工具,开启线程,在子线程里循环执行任务,发现不能退出程序,然后折腾了半天,还是退出不了,最后发现,原来是个bug

    今天写一个小工具,开启多个线程,在子线程里循环执行任务,发现不能退出程序,然后折腾了半天,还是退出不了,最后发现,原来是个bug


    先上简化了的代码:

    import sys
    import threading
    import signal
    import time
    
    
    class myThread(threading.Thread):
        def __init__(self):
            threading.Thread.__init__(self)
        def run(self):
            while True:
                time.sleep(1)
    def handler(signum, frame):
        print("exit")
        sys.exit()
    
    if __name__ == "__main__":
        signal.signal(signal.SIGINT, handler)
        threads = []
        for _ in range(0,2):
            t = myThread()
            t.setDaemon(True)
            threads.append(t)
            t.start()
        for _ in range(0,2):
            t.join()
        # while True:pass

    主线程里开启了两个子线程,子线程啥事都不干,醒了就睡,睡醒了接着睡,如此循环往复。并将它们设为daemon线程,

    按我的理解daemon线程就是指当主线程代码执行完退出后,那么daemon子线程也会结束任务并退出,而非daemon线程会不管主线程,它会一如既往的执行自己的任务,直到结束才退出,当所有线程都退出了,那么这个进程就结束了。。

    主线程注册了一个SIGINT信号,当接收到这个信号就退出主线程,ctr+c就向这个主线程发送SIGINT信号,然后按照这个流程,当按下ctr+c的时候应该打印exit后退出进程,然后什么事情都没发生。。

    然后查资料发现这居然是一个bug,我的天。详细地址:https://bugs.python.org/issue1167930

    当主线程join并且子线程没有结束的时候,会阻塞在那,而且不会接受任何信号。。

    然而这个bug他们并没有修复,只是建议用timeout参数来规避。。


    更奇怪的是,python3(我用的3.4)却没有这个bug,join的时候,按下ctr+c可以正常退出进程,上面代码可以直接用python3执行,看来是在python3中把这个问题修复了,至于python2为啥没修复就不知道了,也许有什么难言的苦衷吧,(好象是修复bug会导致其它问题)。。


    网上有很多解决办法,但是一眼看上去有点复杂,我想如果主线程不使用join,而是使用一个while循环挂在那,当然后让主线程退出了,子线程也就推出了。

    试验了一下没问题:

    import sys
    import threading
    import signal
    import time
    
    class myThread(threading.Thread):
        def __init__(self):
            threading.Thread.__init__(self)
    
        def run(self):
            while True:
                time.sleep(1)
    
    def handler(signum, frame):
        print("exit")
        sys.exit()
    
    
    if __name__ == "__main__":
    
        signal.signal(signal.SIGINT, handler)
        threads = []
        for _ in range(0,2):
            t = myThread()
            t.setDaemon(True)
            threads.append(t)
            t.start()
        # for _ in range(0,2):
        #     t.join()
        while True:
            time.sleep(1)


    本人出于个人兴趣,创建了一个个人公众号,每天筛选国外网友发现的有趣的事情推送到公众号,欢迎关注!


    展开全文
  • threads=[] f=[fast,slow] l=len(f) for i in range(l): t=MyThread(f[i],(),str(i)) threads.append(t) for i in range(l): threads[i].start() for i in range(l): ... threads[i].join() p

    	threads=[]
    	f=[fast,slow]
    	l=len(f)
    	for i in range(l):
    		t=MyThread(f[i],(),str(i))
    		threads.append(t)
    	
    	for i in range(l):
    		threads[i].start()
    
    	for i in range(l):
    		#pass
    		threads[i].join()
    		print threads[i].getName()
    	print "Done on main"
    	exit()

    join的主要功能是阻塞线程,也就是使用了join后,后面的语句需要等当前进程完成之后才能 执行。


    那么看看下面的例子


    class MyThread(threading.Thread):
    	def __init__(self,fun,arg,name=""):
    		threading.Thread.__init__(self)
    		self.fun=fun
    		self.arg=arg
    		self.name=name
    		#self.result
    
    
    	def run(self):
    		self.result=apply(self.fun,self.arg)
    	
    	def getName(self):
    		return self.name
    
    
    	def getResult(self):
    		return self.result

    上面是一个多线程的类。 待会用来调用的。

    下面是main函数

    def fast():
    	print "in fast"
    	sleep(15)
    	print "done in fast"
    
    def slow():
    	print "in slow"
    	sleep(10)
    	print "done in slow"

    	threads=[]
    	f=[fast,slow]
    	l=len(f)
    	for i in range(l):
    		t=MyThread(f[i],(),str(i))
    		threads.append(t)
    	
    	for i in range(l):
    		threads[i].start()
    
    	for i in range(l):
    		#pass
    		threads[i].join()
    		print threads[i].getName()
    	print "Done on main"
    	exit()


    运行之后
    输出的结果是

    in fast
    in slow
    done in slow
    done in fast
    0
    1
    Done on main


    看到了吗?


    运行到thread[i].join() 这一行, 下一句没有马上被执行,需要等到done in fast 完成之后才执行, 而为什么done in slow却提前被执行了呢?


    因为上面执行了threads[i].start() 后 两个线程已经同时开启了,但是由于在slow线程里只sleep了10秒,而fast线程sleep了15秒,所以会先打印done in slow。


    print threads[i].getName()

    而上面这句则需要等线程1执行之后才会执行,

    等执行完了上面那句之后,才会执行线程2的 join(), 由于此时的线程已经早已执行完毕,所以这句也没有起到阻塞作用,故会马上执行 下面只一句


    print threads[i].getName()
    展开全文
  • Python多线程join()

    2016-03-17 10:14:25
    Python多线程join() 本文介绍介绍的是thread.threading的 join方法 join(timeout=None):
  • Python多线程与多进程中join()方法的效果是相同的。 下面仅以多线程为例: 首先需要明确几个概念: 知识点一: 当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置多线程时,主线程...
  • Python多线程2 join()

    千次阅读 2020-01-11 11:21:48
    一句话:对于 线程i.join() 这一行代码,其后的代码都要等待线程i完成之后才能执行。 import threading import time def T1_job(): print('T1 start\n') time.sleep(1) print('T1 finished') def T2_job(): ...
  • Python线程join()方法

    千次阅读 2018-01-02 09:43:27
    1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样 2 如果创建线程,并且设置了daemon为true,即thread.setDaemon(True), 则主线程执行完毕后自动退出,...
  • Python 多线程join()的用法

    千次阅读 2019-08-30 16:21:13
    对于多线程 Thread 对象的 join(timeout=None) 属性 官方解释是:直至启动的线程终止之前一直挂起,除非给出了 timeout(秒) ,否则会一直阻塞 其实真正的意思就是除非子线程也全部运行完毕,否则主线程一直挂起 下面...
  • Python多线程编程时,经常会用到join()和setDaemon()方法,今天特地研究了一下两者的区别。1、join ()方法:主线程A中,创建了子线程B,并且在主线程A中调用了B.join(),那么,主线程A会在调用的地方等待,直到子...
  • python多线程教程:python多线程详解

    千次阅读 2020-02-03 11:49:20
    文章目录一、线程介绍二...python多线程详解 一、线程介绍 什么是线程 线程(Thread)也叫轻量级进程,是操作系统能够进行运算调度的最小单位,它被包涵在进程之中,是进程中的实际运作单位。线程自己不拥有系统资源...
  • python多线程join的用法

    千次阅读 2017-05-16 11:25:49
    python多线程join是用来阻塞主线程的。  看下面的例子: def fast(): print "in fast" sleep(10) print "done in fast" def slow(): print "in slow" sleep(15) print "done in slow" 一个运行快,一个...
  • 同一进程下的多个线程共享...某些场景下我们可以使用多线程来达到提高程序执行效率的目的,下面就多线程的一些基础知识做简要说明 简单的多线程 mport threading, time def test1(x): time.sleep(5) print(x**...
  • Python多线程003之详解 join

    千次阅读 2018-04-08 11:25:55
    import threading import time ...#用类的方法实现多线程 class MyThread(threading.Thread): def __init__(self,n,sleep_time): super(MyThread,self).__init__() self.n = n self.sleep_time = sl...
  • Python多线程编程中,经常碰到 thread.join()这样的代码。那么今天咱们用实际代码来解释一下 join 函数的作用。 第一,当一个进程启动之后,会默认产生一个主线程,因为线程是程序执行流的最小单元,当设置...
  • Python 多线程 thread join() 的作用

    万次阅读 2018-03-03 00:23:59
    原文地址在 Python多线程编程中,在实例代码中经常有 thread1.join()这样的代码。那么今天咱们用实际代码来解释一下 join 函数的作用。 join的原理就是依次检验线程池中的线程是否结束,没有结束就阻塞直到线程...
  • python多线程中的join()

    千次阅读 2018-10-21 11:20:35
    先看一个例子,该例子没用到join。  添加一个线程,输出“start”和“finish”标记线程的开始和结束。线程added_thread和线程main同时运行,其中added_thread消耗较长的时间(通过线程sleep模拟)。mian执行结束后...
  • Python多线程之阻塞join和线程守护setDeamon多线程默认情况设置线程守护setDaemon的作用线程阻塞join作用 多线程默认情况 无阻塞无线程守护。 import threading import time def run(process = 'python'): time....
  • Python作为目前跨平台应用最火的 编程语言 ,已经被很多行业的研究人员所使用,其实与其他编程语言相同,Python也只支持多线程编程,而且Python对于线程的支持也提供了很多方便的方法可以直接调用,从而可以很好的...
  • join()表示要堵塞主线程直到这个线程完成,并不影响子线程的同时进行,只是代表在join()后边的语句必须等待join的这个线程完成才能执行: import threading def job1(): global A for i in range(10): A+=1 ...
  • Python多线程编程的时候,经常需要用到join函数和setDaemon函数。之前对这两个函数一直理解不是很到位。今天查阅了很多资料,对两个函数的认识更加的深入一些了。 join([timeout])可以参考Python文档说明。大概...
  • Python多线程中的join函数的使用与含义

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,401
精华内容 19,760
关键字:

python多线程join

python 订阅