精华内容
下载资源
问答
  • 主要介绍了Python线程:主线程等待所有子线程结束代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class ExcetuorDemo2 {
    public static void main(String[] args) {
    ExecutorService service = Executors.newFixedThreadPool(5);
    CountDownLatch cdl = new CountDownLatch(5);
    Handler t1 = new Handler(cdl);
    Handler t2 = new Handler(cdl);
    Handler t3 = new Handler(cdl);
    Handler t4 = new Handler(cdl);
    Handler t5 = new Handler(cdl);
    service.execute(t1);
    service.execute(t2);
    service.execute(t3);
    service.execute(t4);
    service.execute(t5);
    service.shutdown();
    try {
    cdl.await();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println("over");
    }
     
    }
    class Handler implements Runnable {
    CountDownLatch cdl;
    public Handler(CountDownLatch cdl){
    this.cdl = cdl;
    }
    @Override
    public void run() {
    for(int i=0;i<1;i++){
    try {
    Thread.sleep(1000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + "   " + i);
    }
    cdl.countDown();
    }
    }


    转载于:https://my.oschina.net/u/1793291/blog/343532

    展开全文
  • 这篇文章主要介绍了python主线程与子线程结束顺序实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 引用自 主线程退出对子线程的影响 的一段话: 对于...
  • 我就废话不多说了,还是直接看代码吧!from time import ctimeimport threadingimport timedef a():#for i in range(5):print("Program a is running......线程名为:",threading.current_thread().name...

    我就废话不多说了,还是直接看代码吧!

    from time import ctime

    import threading

    import time

    def a():

    #for i in range(5):

    print("Program a is running... at ", ctime(),u".线程名为:",threading.current_thread().name )

    time.sleep(0.2)

    def b(x):

    #for i in range(5):

    print("Program b("+x+") is running... at ", ctime(),u".线程名为:",threading.current_thread().name )

    time.sleep(0.1)

    if __name__ == "__main__":

    print("Mainthread %s is running..." % threading.current_thread().name)

    thread_list = []

    for i in range(400):#同时运行多个

    t1= threading.Thread(target=a)

    thread_list.append(t1)

    t2 = threading.Thread(target=b, args=("Python",))

    thread_list.append(t2)

    t3 = threading.Thread(target=b, args=("Java",))

    thread_list.append(t3)

    for t in thread_list:

    t.setDaemon(True) # 设置为守护线程,不会因主线程结束而中断

    t.start()

    for t in thread_list:

    t.join() # 子线程全部加入,主线程等所有子线程运行完毕

    print("Mainthread %s ended." % threading.current_thread().name)

    补充知识:Python主线程结束为什么守护线程还在运行?

    在实际的交互模式中,主线程只有在Python退出时才终止,所以action函数输出结果还是被打印出来了。”

    按照我的理解应该是说,在shell里主线程在输出结果之后并没有真的结束,所以action还会打印结果。

    建议把程序编译出来,放到另外的环境中测试,估计就会是你要的结果了。

    以上这篇Python多线程:主线程等待所有子线程结束代码就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

    本文标题: Python多线程:主线程等待所有子线程结束代码

    本文地址: http://www.cppcns.com/jiaoben/python/310078.html

    展开全文
  • from time import ctime import threading import time def a(): #for i in range(5): print('Program a is running... at ', ctime(),u'.线程名为:',threading.current_thread().name ) time.slee...

    from time import ctime
    import threading
    import time

    def a():
        #for i in range(5):
            print('Program a is running... at ', ctime(),u'.线程名为:',threading.current_thread().name )
            time.sleep(0.2)
            
    def b(x):
        #for i in range(5):
            print('Program b('+x+') is running... at ', ctime(),u'.线程名为:',threading.current_thread().name )
            time.sleep(0.1)
            

    if __name__ == '__main__':
        print('Mainthread %s is running...' % threading.current_thread().name)
        thread_list = []
        for i in range(400):#同时运行多个
           t1= threading.Thread(target=a)
           thread_list.append(t1)
           
        t2 = threading.Thread(target=b, args=('Python',))
        thread_list.append(t2)
        t3 = threading.Thread(target=b, args=('Java',))
        thread_list.append(t3)
        

        for t in thread_list:
            t.setDaemon(True)  # 设置为守护线程,不会因主线程结束而中断
            t.start()
        for t in thread_list:
            t.join()  # 子线程全部加入,主线程等所有子线程运行完毕

        print('Mainthread %s ended.' % threading.current_thread().name)
     

    展开全文
  • 主线程退出后子线程的状态依赖于它所在的进程,如果进程没有退出的话子线程依然正常运转。如果进程退出了,那么它所有的线程都会退出,所以子线程也就退出了。 主线程退出,进程等待所有子线程执行完毕后才结束 进程...

    对于程序来说,如果主进程在子进程还未结束时就已经退出,那么Linux内核会将子进程的父进程ID改为1(也就是init进程),当子进程结束后会由init进程来回收该子进程。

    主线程退出后子线程的状态依赖于它所在的进程,如果进程没有退出的话子线程依然正常运转。如果进程退出了,那么它所有的线程都会退出,所以子线程也就退出了。
    主线程退出,进程等待所有子线程执行完毕后才结束

    进程启动后会默认产生一个主线程,默认情况下主线程创建的子线程都不是守护线程(setDaemon(False))。因此主线程结束后,子线程会继续执行,进程会等待所有子线程执行完毕后才结束

    所有线程共享一个终端输出(线程所属进程的终端)

    import threading
    import time
    
    def child_thread1():
        for i in range(100):
            time.sleep(1)
            print('child_thread1_running...')
    
    def parent_thread():
        print('parent_thread_running...')
        thread1 = threading.Thread(target=child_thread1)
        thread1.start()
        print('parent_thread_exit...')
    
    if __name__ == "__main__":
        parent_thread()
    

    输出为:

    parent_thread_running...
    parent_thread_exit...
    child_thread1_running...
    child_thread1_running...
    child_thread1_running...
    child_thread1_running...
    ...
    

    可见父线程结束后,子线程仍在运行,此时结束进程,子线程才会被终止
    主线程结束后进程不等待守护线程完成,立即结束

    当设置一个线程为守护线程时,此线程所属进程不会等待此线程运行结束,进程将立即结束

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    import threading
    import time
    
    def child_thread1():
        for i in range(100):
            time.sleep(1)
            print('child_thread1_running...')
    
    def child_thread2():
        for i in range(5):
            time.sleep(1)
            print('child_thread2_running...')
    
    def parent_thread():
        print('parent_thread_running...')
        thread1 = threading.Thread(target=child_thread1)
        thread2 = threading.Thread(target=child_thread2)
        thread1.setDaemon(True)
        thread1.start()
        thread2.start()
        print('parent_thread_exit...')
    
    if __name__ == "__main__":
        parent_thread()
    

    输出:

    parent_thread_running...
    parent_thread_exit...
    child_thread1_running...child_thread2_running...
    
    child_thread1_running...child_thread2_running...
    
    child_thread1_running...child_thread2_running...
    
    child_thread1_running...child_thread2_running...
    
    child_thread2_running...child_thread1_running...
    
    Process finished with exit code 0
    

    thread1是守护线程,thread2非守护线程,因此,进程会等待thread2完成后结束,而不会等待thread1完成

    注意:子线程会继承父线程中daemon的值,即守护线程开启的子线程仍是守护线程
    主线程等待子线程完成后结束

    在线程A中使用B.join()表示线程A在调用join()处被阻塞,且要等待线程B的完成才能继续执行

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    import threading
    import time
    
    def child_thread1():
        for i in range(10):
            time.sleep(1)
            print('child_thread1_running...')
    
    def child_thread2():
        for i in range(5):
            time.sleep(1)
            print('child_thread2_running...')
    
    def parent_thread():
        print('parent_thread_running...')
        thread1 = threading.Thread(target=child_thread1)
        thread2 = threading.Thread(target=child_thread2)
        thread1.setDaemon(True)
        thread2.setDaemon(True)
        thread1.start()
        thread2.start()
        thread2.join()
        1/0
        thread1.join()
        print('parent_thread_exit...')
    
    if __name__ == "__main__":
        parent_thread()
    

    输出:

    parent_thread_running...
    child_thread1_running...
    child_thread2_running...
    child_thread1_running...
    child_thread2_running...
    child_thread1_running...
    child_thread2_running...
    child_thread1_running...
    child_thread2_running...
    child_thread1_running...
    child_thread2_running...
    Traceback (most recent call last):
      File "E:/test_thread.py", line 31, in <module>
        parent_thread()
      File "E:/test_thread.py", line 25, in parent_thread
        1/0
    ZeroDivisionError: integer division or modulo by zero
    

    主线程在执行到thread2.join()时被阻塞,等待thread2结束后才会执行下一句

    1/0 会使主线程报错退出,且thread1设置了daemon=True,因此主线程意外退出时thread1也会立即结束。thread1.join()没有被主线程执行

    展开全文
  • 1.主进程会等待所有进程结束后才会程序结束 2.主线程也会等待所有子线程结束后才会主线程结束 3.from multiprocessing import Pool这个进程池,并不会等待所有的进程运行完成,而是主线程代码执行完成后程序就立即...
  • 困于心衡于虑而后作 今天的学习目标是:python的线程等待和线程锁 1.线程等待 线程等待 在多线程的程序中往往一个线程...# 主线程启动子线程等待结束后再执行 import threading import time import random def re
  • python之多线程

    2020-01-09 10:56:23
    1, 若主线程无代码执行,主线程将等待子线程结束而结束。 2, 线程的运行并无先后顺序。 3, 若主线程因特殊原因先结束,子线程也同时结束。 4, 只有当用Thread创建出来的实例对象,被start方法调用时,才会创建...
  • 目录 1.问题 2.线程使用模块 3.threading模块使用例子 ...python如何使用线程 ...第一、thread模块的主线程结束时不会等待子线程结束,所有的子线程在主线程退出后强制退出。 第二、thread模块的线...
  • python的多线程线程同步方式

    千次阅读 2019-07-17 09:37:23
    1.线程执行 join与setDaemon 1.子线程在主线程运行结束后,会继续执行完,...如果join()线程,那么主线程会等待子线程执行完再执行。 import threading import time def get_thread_a(): print("get thread...
  • python线程教程:python线程详解

    千次阅读 2020-02-03 11:49:20
    文章目录一、线程介绍二、线程实现threading模块自定义线程守护线程主线程等待子线程结束多线程共享全局变量递归锁事件(Event类)三、GIL(Global Interpreter Lock)全局解释器锁 python多线程详解 一、线程介绍 ...
  • 文章目录线程python的thread模块是比较底层的... 主线程会等待所有的子线程结束后才结束3. 查看线程数量 线程 python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便...
  • python的多线程编程

    2020-10-29 11:22:21
    主线程结束后进程不等待守护线程完成,守护线程连同主线程立即结束 根据特性分析,守护进程一般运行着可以随时被结束的程序。 而非守护进程,一般运行着不能随时结束,需要处理善后的程序。例如释放资源、或者备份...
  • Python线程

    2020-08-15 14:06:41
    而在python中,主线程结束后,会默认等待子线程结束后,主线程才退出。 python对于thread的管理中有两个函数:join和setDaemon join:如在一个线程B中调用threada.join(),则threada结束后,线程B才会接着...
  • 主线程会等待子线程结束才能结束 只要有一个线程不是守护主线程,主线程都会等待该子线程执行完之后再结束,期间其他守护主线程都可以继续执行 2.线程的创建 创建线程分为3步 1.导入线程包 2.创建线程对象 3.开始...
  • Python中daemon线程

    千次阅读 2018-08-16 00:33:38
    如果某个子线程的daemon属性为False,主线程结束时会检测该子线程是否结束,如果该子线程还在运行,则主线程会等待它完成后再退出; 如果某个子线程的daemon属性为True,主线程运行结束时不对这个子线程进行检查而...
  • 线程1 简介2 多线程的使用2.1 导入线程模块2.2 创建线程2.2.1普通创建方式+传参2.2.2继承方式创建(未看)2.3 主线程会等待所有的子线程执行结束结束2.4 .setDaemon() 方法2.5 .join()方法2.6.threading模块提供...
  • 在一个含有线程的python程序中,当主线程的代码运行完之后,如果还有其他子线程还未执行完毕,那么主线程会等待子线程执行完毕之后,再结束;如果有一个线程必须设置为无限循环,那么该线程不结束,意味着整个python...
  • python线程详解

    2019-08-02 16:06:00
    目录 python多线程详解 一、线程介绍 什么是线程 为什么要使用多线程 二、线程实现 threading模块 自定义线程 守护线程 主线程等待子线程结束 多线程共享全局变量 ...
  • 1.使用join函数后,主进程会在调用join的地方等待子线程结束,然后才接着往下执行。 join使用实例如下: import time import random import threading class worker(threading.Thread): def __init__(self): ...
  • Python 进程和线程

    2019-04-28 11:39:00
    有些进程不止同时干一件事,如word可以同时进行打字、拼写检查、打印等事情,进程内的任务称为线程 多进程 multiprocessing模块 跨平台版本的多进程模块 启动一个子进程并等待结束 1 #!/usr/bin/python...
  • 主线程等待子线程执行结束;线程和线程之间,数据是共享的。 python中有两种方式实现线程,两种方式本质上都是直接或者间接使用threading.Thread类: 1、实例化一个threading.Thread的对象,并传入一个初始化函数...
  • Python线程同步

    2018-10-03 00:07:00
    Python线程同步 线程执行 join与setDaemon ...子线程在主线程运行结束后,会继续执行完,...如果join()线程,那么主线程会等待子线程执行完再执行。 1 import threading 2 import time 3 ...
  • 文章目录进程进程的概念多进程获取进程号获取当前进程号获取父进程号带参数传递的进程argskwargs进程之间不共享全局变量主进程会等待所有的进程结束后再结束守护进程销毁进程线程线程的概念多线程使用多线程首先...
  • python高级:线程

    2021-05-11 16:34:25
    1.1 **MAC和Linux下:**1.2 **Windows下:**1.3 **关于Thread的说明:**二、获取线程编号三、线程的注意点3.1 线程之间执行是无序的3.2 主线程会等待所有的子线程执行结束结束3.3 线程之间共享全局变量3.4 线程...
  • python线程join

    2019-09-26 14:37:33
    几个事实 1 python 默认参数创建线程后,不管主线程是否执行完毕,都会等待子线程执行完毕才一起退出,有无join结果一样 ...3 join方法的作用是阻塞,等待子线程结束,join方法有一个参数是timeo...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 164
精华内容 65
关键字:

python等待子线程结束

python 订阅