python笔记——join方法与守护线程setDaemon()

最新推荐文章于 2023-01-20 14:08:47 发布
最新推荐文章于 2023-01-20 14:08:47 发布
阅读量366 收藏 3
点赞数
分类专栏： 为了进行共识算法仿真而做的努力 文章标签： 区块链 多线程 python thread 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/legendary_idiot/article/details/114043872
版权

通俗地讲，threading.Thread子类的join方法，是一个用来阻塞主线程的方法。就是就是在某个子线程执行到该语句时，让这个线程执行完毕，才会继续执行其他子线程，当所有调用了join方法的子线程执行结束，主线程才会结束。
而引入了参数timeout，给了每个子线程规定的阻塞时间，为join方法添加了很多用法；另外结合setDaemon()方法，在有无守护进程的场景下战线出了不同作用，以下是结合二者的分析。

1、无join，setDaemon(False)
import time
import threading

class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            print('thread {}, @number: {}'.format(self.name, i))
            time.sleep(1)


def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
        t.start()
    print("End Main threading")

if __name__ == '__main__':
    main()

该模块在main()主线程中，实例化了三个子线程的对象，其中每个子线程的任务是打印五句话，每次打印之间间隔一秒。

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-3, @number: 0
End Main threading
thread Thread-1, @number: 1
thread Thread-3, @number: 1
thread Thread-2, @number: 1
thread Thread-3, @number: 2
thread Thread-2, @number: 2
thread Thread-1, @number: 2
thread Thread-1, @number: 3
thread Thread-3, @number: 3
thread Thread-2, @number: 3
thread Thread-1, @number: 4
thread Thread-2, @number: 4
thread Thread-3, @number: 4

结果表明，正常情况下，并发执行的三个子线程每一次打印的行为在一秒内完成，主线程也在一秒内完成，子线程剩下的任务则在余下的四秒后完成。

2、无join，setDaemon(True)
def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
    	t.setDaemon(True)
        t.start()
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-3, @number: 0
End Main threading

此时，只要主线程执行完毕，会立即结束子线程的运行。因为主线程在一秒内执行完，因此只能打印出第一轮循环的结果。

3、有join无参数，setDaemon(False)
def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
        t.start()
        t.join()
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-1, @number: 1
thread Thread-1, @number: 2
thread Thread-1, @number: 3
thread Thread-1, @number: 4
thread Thread-2, @number: 0
thread Thread-2, @number: 1
thread Thread-2, @number: 2
thread Thread-2, @number: 3
thread Thread-2, @number: 4
thread Thread-3, @number: 0
thread Thread-3, @number: 1
thread Thread-3, @number: 2
thread Thread-3, @number: 3
thread Thread-3, @number: 4
End Main threading

def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-3, @number: 0
thread Thread-1, @number: 1
thread Thread-3, @number: 1
thread Thread-2, @number: 1
thread Thread-1, @number: 2
thread Thread-2, @number: 2
thread Thread-3, @number: 2
thread Thread-2, @number: 3
thread Thread-3, @number: 3
thread Thread-1, @number: 3
thread Thread-3, @number: 4
thread Thread-1, @number: 4
thread Thread-2, @number: 4
End Main threading

对比这两种情况：
第一种情况是每个子线程运行后立马调用join方法，这样会使得程序等待该子线程执行完毕后，才会执行下一个子进程，当所有的子线程执行结束后，才会结束主线程。
第二种情况是，三个子线程同时开始执行，执行后依次调用join方法，这样的运行结果和没有join方法时类似，只不过主线程会在所有子线程运行结束后才结束。
那join的作用，是否是只影响调用该方法之后的子线程呢，调用该方法之前就开始运行的子线程不受其影响吗？

def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    t1 = threads[0]
    t2 = threads[1]
    t3 = threads[2]

    t1.start()
    t2.start()
    t1.join()
    t2.join()

    t3.start()
    t3.join()
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-2, @number: 1
thread Thread-1, @number: 1
thread Thread-2, @number: 2
thread Thread-1, @number: 2
thread Thread-2, @number: 3
thread Thread-1, @number: 3
thread Thread-2, @number: 4
thread Thread-1, @number: 4
thread Thread-3, @number: 0
thread Thread-3, @number: 1
thread Thread-3, @number: 2
thread Thread-3, @number: 3
thread Thread-3, @number: 4
End Main threading

结果表明，join阻塞了子线程3和主线程。子线程1和2并行执行，直到结束才开始3的执行。因此，join只影响其后的线程。

4、有join有参数，setDaemon(False)
def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
        t.start()
        t.join(2)
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-1, @number: 1
thread Thread-2, @number: 0
thread Thread-1, @number: 2
thread Thread-2, @number: 1
thread Thread-1, @number: 3
thread Thread-3, @number: 0
thread Thread-2, @number: 2
thread Thread-1, @number: 4
thread Thread-3, @number: 1
thread Thread-2, @number: 3
End Main threading
thread Thread-3, @number: 2
thread Thread-2, @number: 4
thread Thread-3, @number: 3
thread Thread-3, @number: 4

当设置join方法的timeout参数时，主线程会等待所有子线程各自的timeout之和，之后主线程结束，子线程继续执行。（在End Main threading之前，执行了六秒）

def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
        t.start()
    for t in threads:
        t.join(1)
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-3, @number: 0
thread Thread-3, @number: 1
thread Thread-1, @number: 1
thread Thread-2, @number: 1
thread Thread-3, @number: 2
thread Thread-2, @number: 2
thread Thread-1, @number: 2
End Main threading
thread Thread-1, @number: 3
thread Thread-3, @number: 3
thread Thread-2, @number: 3
thread Thread-1, @number: 4
thread Thread-3, @number: 4
thread Thread-2, @number: 4

即便是在所有子线程开始后，也同样等待六秒，主线程结束，其余子线程继续执行。区别在于子线程的执行顺序，这个顺序和join无参数的情况是一致的。

5、有join无参数，setDaemon(True)
def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
    	t.setDaemon(True)
        t.start()
    for t in threads:
        t.join()
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-2, @number: 0
thread Thread-3, @number: 0
thread Thread-1, @number: 1
thread Thread-2, @number: 1
thread Thread-3, @number: 1
thread Thread-1, @number: 2
thread Thread-2, @number: 2
thread Thread-3, @number: 2
thread Thread-2, @number: 3
thread Thread-3, @number: 3
thread Thread-1, @number: 3
thread Thread-2, @number: 4
thread Thread-3, @number: 4
thread Thread-1, @number: 4
End Main threading

守护线程只作用于主线程，上述代码的主线程是当所有子线程执行完毕后执行完，因此从结果来看，并无差异。
同样，在每个子线程开始后立马执行无参数join语句，因为主线程本身就是最后结束，因此守护线程情况下，效果也无差异。（省略代码以及结果）

6、有join有参数，setDaemon(True)
def main():
    print("Start main threading")
    threads = [MyThread() for i in range(3)]
    for t in threads:
    	t.setDaemon(True)
        t.start()
        t.join(1)
    print("End Main threading")

Start main threading
thread Thread-1, @number: 0
thread Thread-1, @number: 1
thread Thread-2, @number: 0
thread Thread-1, @number: 2
thread Thread-2, @number: 1
thread Thread-3, @number: 0
thread Thread-1, @number: 3
End Main threading
thread Thread-3, @number: 1

每个子线程开始后立即执行join一秒的语句，当他们的时间之和结束后，主线程结束，线程没有执行完毕的部分被强制杀死。另一种情况也是如此。
这里需要注意的是，End语句打印后又打印了一句，而另一种join位置也是如此，我分析，这是因为执行print这句话的时候，已经是第四秒开始，主线程结束这句话所消耗的时间，子线程会继续执行，直到真正终止的时刻。因此会有一些超过三秒的打印语句被打印的情况。

总结

join的主要目的就是阻塞主线程
join无参数时，join阻塞了其语句之后才开始的子线程和主线程
join有参数时：

  1. 守护线程时，主线程等待所有子线程join的timeout时间之和，之后杀死所有子线程，退出程序。
  2. 非守护线程时，主线程等待所有子线程timeout时间之和，之后主线程结束，子线程继续执行直到结束。
牛奶抹茶冰淇淋
关注
专栏目录
python多线程中的守护线程以及join()方法
mjjyszazc的博客
05-10 1605
一、守护线程 要理解守护线程（不分语言），这里有三个问题需要弄清楚： 守护线程顾名思义就是守护别的线程，守护谁呢？一个进程中的主线程，是任何进程中都一定会存在的东西 守护到什么时候呢？主线程运行结束的时候，被守护者都结束退出了，守护者自然没有存在的意义要终止了 与普通子线程有什么区别呢？普通子线程与主线程之间没有谁等待谁结束的关系，竞争地位等同，一个进程中可能是主线程先结束，主线程结束后，...
Python多线程与多线程中join()的用法
最新发布
2301_79099460的博客
04-21 566
没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。此时join的作用就凸显出来了，join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止，例子见下面三。主线程的任务完成之后，主线程随之结束，子线程继续执行自己的任务，直到全部的子线程的任务全部结束，程序结束。其执行结果如下，注意请确保setDaemon()在start()之前。
Python 多线程中的 join() 和 setDaemon()
Looking的博客
03-09 821
Demo 是最好的老师！！！ 知识点一： 当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在 python 中，默认情况下（其实就是setDaemon(False)），主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束。 import threading import time def run(): time.sleep(2) print('当前线程的名字是： ', thread
python线程join方法与seDaemon方法
weixin_34281477的博客
11-23 102
前言 基于上篇文章之后,我们了解了python程序执行流程,为什么要使用线程,以及什么情况下使用python线程,本文继此之后说说python多线程编程时,经常用到的join()和setDaemon()方法. join()方法 join ()方法：主线程(主程序)A中，创建了子线程B，并且在主线程A中调用了B.join()方法(或多个线程中的一个joi...
python setDaemon
敖尔其楞的专栏
08-15 2228
一开始适用shell插入， for i in {1..10000000} do name=date +%s%N | md5sum | head -c 10 /usr/local/mysql-5.7.18/bin/mysql -uroot -p123456 -h 10.xxx -P4444 baixyu -e “insert into tb1(id,userid,name,bi
python之线程threading模块和多线程启动不同浏览器
公子清羽的博客
09-27 479
import threading import time def test(): for i in range(10): print("test is run:", i) time.sleep(1) if __name__ == '__main__': # 创建子线程 t1 = threading.Thread(target=test) t1.setDaemon(True) #设置t1（test函数）为守护线程，当主线程结束了，也随之结束.
Python进阶学习笔记之——多线程编程
前尘忆梦的博客
08-21 465
多线程编程 1、Python 的多线程支持模块简介 Python 提供了多个模块来支持多线程编程，包括 thread、threading 和 Queue 模块等。程序是可以使用 thread 和 threading 模块来创建与管理线程。thread 模块提供了基本的线程和锁定支持；而 threading 模块提供了更高级别、功能更全面的线程管理。使用 Queue 模块，用户可以创建一支队列数据结构，用于在多线程之间进行共享。 核心提示：避免使用 thread 模块 推荐使用更高级别的 threadin
python多线程第一课笔记（csdn）————程序.pdf
12-03
这篇笔记主要讲解了Python中的多线程基础知识，包括单线程、多线程的创建、守护线程以及线程的join方法。 1. 单线程： 在Python中，程序默认是单线程执行的。例如，`test_1`和`test_2`两个函数按照顺序执行，`test_...
python学习笔记——线程threading （二）重写run()方法和守护进程daemon()
weixin_33711647的博客
04-08 1913
1 run()方法 1.1 单个线程 在threading.Thread()类中有run()方法。 from time import ctime,sleep import threading # 定义自己类的功能 class MyThread(threading.Thread): def __init__(self,func,args,name = ""): ...
python线程卡死问题解决_Python线程，以及多线程带来的数据错乱和死锁的解决方法...
weixin_39731271的博客
11-26 2376
摘至本人有道云笔记《Python线程》1.python多线程的创建在Python中，同样可以实现多线程，有两个标准模块thread和threading，不过我们主要使用更高级的threading模块threading模块提供的类：Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local。threading 模块提...
python 守护线程运用_对python 多线程中的守护线程与join的用法详解
weixin_30784365的博客
02-09 192
多线程：在同一个时间做多件事守护线程：如果在程序中将子线程设置为守护线程，则该子线程会在主线程结束时自动退出，设置方式为thread.setDaemon(True)，要在thread.start()之前设置，默认是false的，也就是主线程结束时，子线程依然在执行。thread.join()：在子线程完成运行之前，该子线程的父线程(一般就是主线程)将一直存在，也就是被阻塞实例：#!/usr/bin...
python Thread.setDaemon()
张帅的博客
07-16 524
如果执行：threading.Tread(target=,*args=()).setDaemon()那么主线程结束后，子线程会被立刻杀死。
Python多线程学习 setDaemon方法
tycoon的专栏
08-22 4230
（2）setDaemon方法：
python线程setDaemon
c_tianzi的专栏
03-05 1483
在python中，主线程结束后，会默认等待子线程结束后，主线程才退出，如下： #coding=utf-8 import threading import time class mythread(threading.Thread): def __init__(self): super().__init__() def run(self): for i in range(5):
Python线程join和setDaemon
Python热爱者的博客
12-15 273
看一下线程的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 the exception, performs cleanup if needed"""
python之守护线程
likunkun__的博客
09-26 471
守护线程与非守护线程： 守护线程会随着非守护线程结束而结束（比如主线程和其他副线程）。 守护线程：只要主线程执行完毕，不等其他线程，就退出程序 就是等待非守护线程执行完毕就退出 设置守护线程： t.setDaemon(True) 一定要在start之前 ...
Python多线程之join方法与守护线程
u013887652的博客
10-25 527
大神请绕道 join在多线程中的作用 当先看一段代码，并判断一下这个cost的值为多少 import threading, time def a(): print('in a') time.sleep(2) print('out a') def b(): print('in b') time.sleep(3) print('out b') if __...
python多线程之setDaemon和join
weixin_47831992的博客
10-18 1508
currentThread() . name } ---->开始输入任务...') time . sleep(1) print(f' {currentThread() . name } ---->完成输入任务...') def get_task() : print(f' {currentThread() . name } ---->开始消费任务...') time . sleep(1) print(f' {
setDaemon python守护进程，队列通信子线程
木下瞳的博客
01-20 1634
使用setDaemon()和守护线程这方面知识有关， 比如在启动线程前设置thread.setDaemon(True)，就是设置该线程为守护线程，thread.setDaemon（）设置为True, 则主线程执行完毕后会将子线程回收掉,设置为false,主进程执行结束时不会回收子线程。与队列一起使用，主进程需要一个子线程处理东西，共享一个变量，他们的通信就可以用队列，当主进程有元素塞入，子线程才会处理，这样做的意义在于：避免子线程无限死循环，导致退不出程序，也就是避免传说中的孤儿进程。
Python多线程Threading实战：子线程与守护线程解析
"Python多线程Threading、子线程与守护线程的实例解析，包括线程与进程的概念，Threading模块的使用，以及如何创建和管理线程，特别是子线程和守护线程的应用" 在Python编程中，多线程是一个关键的概念，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值