Python线程/进程-join

最新推荐文章于 2024-04-08 02:45:00 发布
最新推荐文章于 2024-04-08 02:45:00 发布
阅读量1k 收藏 7
点赞数 3
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014783334/article/details/125934957
版权

目录

1、默认创建线程，不使用 join时

2、创建线程，设置守护线程，不使用join

3、默认创建线程，使用join

4、创建线程，设置守护线程，使用join

5、默认创建线程，使用join，并设置timeout时间

6、创建线程，设置守护线程，使用join，并设置timeout时间

1、默认创建线程，不使用 join时

import threading
import time


def task1():
    print('task--1---starting')
    time.sleep(2)
    print('task--1---end')


def task2():
    print('task--2---starting')
    time.sleep(5)
    print('task--2---end')


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
print(f'当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
t1.start()
print(f't1启动后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
t2.start()
print(f't2启动后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
print('main-thread-go')
print(f'主线程运行到代码最后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')

D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
当前线程数量=1,线程=[<_MainThread(MainThread, started 24136)>]
task--1---starting
t1启动后，当前线程数量=2,线程=[<_MainThread(MainThread, started 24136)>, <Thread(Thread-1, started 6740)>]
task--2---startingt2启动后，当前线程数量=3,线程=[<_MainThread(MainThread, started 24136)>, <Thread(Thread-1, started 6740)>, <Thread(Thread-2, started 20996)>]
main-thread-end

主线程运行到代码最后，当前线程数量=3,线程=[<_MainThread(MainThread, started 24136)>, <Thread(Thread-1, started 6740)>, <Thread(Thread-2, started 20996)>]
task--1---end
task--2---end

Process finished with exit code 0

默认情况，setDaemon的值是False，表示非守护线程。

当主线程运行到代码最后，会等待子线程运行，当子线程运行完成后，子线程会自动结束，再结束主线程

2、创建线程，设置守护线程，不使用join

import threading
import time


def task1():
    print('task--1---starting')
    time.sleep(2)
    print('task--1---end')


def task2():
    print('task--2---starting')
    time.sleep(5)
    print('task--2---end')


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
print(f'当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
t1.setDaemon(True)  # 设置守护线程
t1.start()
print(f't1启动后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
t2.setDaemon(True)  # 设置守护线程
t2.start()
print(f't2启动后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')
print('main-thread-go')
print(f'主线程运行到代码最后，当前线程数量={len(threading.enumerate())},线程={threading.enumerate()}')

D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
当前线程数量=1,线程=[<_MainThread(MainThread, started 5224)>]
task--1---startingt1启动后，当前线程数量=2,线程=[<_MainThread(MainThread, started 5224)>, <Thread(Thread-1, started daemon 20688)>]

task--2---startingt2启动后，当前线程数量=3,线程=[<_MainThread(MainThread, started 5224)>, <Thread(Thread-1, started daemon 20688)>, <Thread(Thread-2, started daemon 9644)>]

main-thread-go
主线程运行到代码最后，当前线程数量=3,线程=[<_MainThread(MainThread, started 5224)>, <Thread(Thread-1, started daemon 20688)>, <Thread(Thread-2, started daemon 9644)>]

Process finished with exit code 0

【守护线程，是为守护别人而存在，当设置为守护线程后，被守护的主线程不存在后，守护线程也自然不存在】

主线程运行，当运行到代码最后，因为子线程有设置延时，不会立刻执行完成，并且因为子线程设置了守护线程，所以主线程运行到最后结束后，子线程没执行完，也立刻结束

3、默认创建线程，使用join

import threading
import time


def task1():
    print('task--1---starting', time.strftime('%H:%M:%S'))
    time.sleep(2)
    print('task--1---end', time.strftime('%H:%M:%S'))


def task2():
    print('task--2---starting', time.strftime('%H:%M:%S'))
    time.sleep(5)
    print('task--2---end', time.strftime('%H:%M:%S'))


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

t1.start()
t2.start()

t1.join()
print(time.strftime('%H:%M:%S'))
t2.join()
print(time.strftime('%H:%M:%S'))
print('main-thread-go')


D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
task--1---starting 17:23:53
task--2---starting 17:23:53
task--1---end 17:23:55
17:23:55
task--2---end 17:23:58
17:23:58
main-thread-go

Process finished with exit code 0

主线程运行到start会启动子线程，然后子线程并发运行，当主线程运行到join，主线程阻塞，并不影响子线程，子线程继续并发运行，主线程会一直等待调用join的子线程执行完后，继续向下执行。

4、创建线程，设置守护线程，使用join

import threading
import time


def task1():
    print('task--1---starting', time.strftime('%H:%M:%S'))
    time.sleep(2)
    print('task--1---end', time.strftime('%H:%M:%S'))


def task2():
    print('task--2---starting', time.strftime('%H:%M:%S'))
    time.sleep(5)
    print('task--2---end', time.strftime('%H:%M:%S'))


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

t1.setDaemon(True)
t1.setDaemon(True)
t1.start()
t2.start()

t1.join()
print(time.strftime('%H:%M:%S'))
t2.join()
print(time.strftime('%H:%M:%S'))
print('main-thread-go')


D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
task--1---starting 17:35:54
task--2---starting 17:35:54
task--1---end 17:35:56
17:35:56
task--2---end 17:35:59
17:35:59
main-thread-go

Process finished with exit code 0

此例运行结果同3一样

5、默认创建线程，使用join，并设置timeout时间

import threading
import time


def task1():
    print('task--1---starting', time.strftime('%H:%M:%S'))
    time.sleep(2)
    print('task--1---end', time.strftime('%H:%M:%S'))


def task2():
    print('task--2---starting', time.strftime('%H:%M:%S'))
    time.sleep(5)
    print('task--2---end', time.strftime('%H:%M:%S'))


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

t1.start()
t2.start()

t1.join(3)
print(time.strftime('%H:%M:%S'))
t2.join(1)
print(time.strftime('%H:%M:%S'))
print('main-thread-go')


D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
task--1---starting 17:48:02
task--2---starting 17:48:02
task--1---end 17:48:04
17:48:04
17:48:05
main-thread-go
task--2---end 17:48:07

Process finished with exit code 0

当运行到 t1.join(3)，主线程阻塞，因为t1只休眠了2秒（虽然join设置了3，但这里实际只会阻塞主线程2秒），所以2秒后t1执行完后，主线程继续向下运行，t2.join(1)，因为t2休眠5秒，join(1)秒并不能执行完，所以1秒后，主线程继续向下执行，一直到代码最后。又因没有设置守护进行，所以会等待子线程执行结束，前面已经休眠了3秒，所以t2继续运行2秒后，执行结束

6、创建线程，设置守护线程，使用join，并设置timeout时间

import threading
import time


def task1():
    print('task--1---starting', time.strftime('%H:%M:%S'))
    time.sleep(2)
    print('task--1---end', time.strftime('%H:%M:%S'))


def task2():
    print('task--2---starting', time.strftime('%H:%M:%S'))
    time.sleep(5)
    print('task--2---end', time.strftime('%H:%M:%S'))


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

t1.setDaemon(True)
t2.setDaemon(True)
t1.start()
t2.start()

t1.join(3)
print(time.strftime('%H:%M:%S'))
t2.join(1)
print(time.strftime('%H:%M:%S'))
print('main-thread-go')


D:\pycharm_workspace\Demo\venv\Scripts\python.exe D:/pycharm_workspace/Demo/main.py
task--1---starting 17:58:04
task--2---starting 17:58:04
task--1---end 17:58:06
17:58:06
17:58:07
main-thread-go

Process finished with exit code 0

当运行到 t1.join(3)，主线程阻塞，因为t1只休眠了2秒（虽然join设置了3，但这里实际只会阻塞主线程2秒），所以2秒后t1执行完后，主线程继续向下运行，t2.join(1)，因为t2休眠5秒，join(1)秒并不能执行完，所以1秒后，主线程继续向下执行，一直到代码最后。又因设置守护进行，主线程直接结束，子线程也一起结束，但由于t2休眠5秒，所以这里t2没执行完就直接结束了，所以没有打印出task--2--end

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

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

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

豌豆code
关注
python 多线程中join()的作用
12-16
温习python 多进程语法的时候，对 join的理解不是很透彻，本文通过代码实践来加深对 join()的认识。 multiprocessing 是python提供的跨平台版本的多进程模块。multiprocessing可以充分利用多核，提升程序运行效率。...
python线程join方法
爱在深秋
10-27 5828
join方法的作用是同步线程。
python进程的join函数
m0_50481455的博客
02-07 1978
python进程的join函数 join让主进程等待子进程结束之后，再执行主进程。 举例： from multiprocessing import Process import time def task(name): print(f"{name} is running") time.sleep(2) print(f"{name} is gone") if __name__ == "__main__": p = Process(target=task,args=("常辛"
Python并发编程：多进程-join方法
liudefang的专栏
02-25 1255
进程只要start就会在开始运行了，所以p1-p4.start()时，系统中已经有四个并发的进程了，而我们p1.join()是在等p1结束，没错p1只要不结束，主线程就会一直卡在原地，这也是问题的关键，join是让主线程等，而p1-p4仍然是并发执行的，p1.join的时候，其余p2，p3，p4仍然在运行，等p1.join结束，可能p2，p3，p4早已经结束了，这样p2.join，p3.join，p4.join直接通过检测，无需等待，所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间。
python线程join()方法使用
nairuozi的博客
11-17 3651
所以运行流程为：main线程启动-->thread1启动--->thread2启动--->thread1与2均阻塞main线程运行-->thread1与2并行运行-->thread1与2运行完毕--->main线程运行结束。时，target=get_target_html(), target=get_target_url()会自动实例化并。可以看出主线程在两个子线程运行完成之前就结束了，两个子线程继续执行直至完成。笔者在第一次写程序时，在调用两个子线程方法时。,类不带括号---赋值，带括号---实例化。
Python多进程(multiprocessing)(mp)(一) —— 进程的创建 & join()方法
hxxjxw的博客
04-24 3486
即使是单核CPU，也能执行多任务 进程&线程 对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。 有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在......
Python多线程处理实例详解【单进程/多进程】
09-19
### Python多线程处理实例详解【单进程/多进程】 #### 概述 在Python编程中，多线程处理是一种非常实用的技术，尤其在需要同时处理多个任务或提高程序执行效率时更为突出。本文将详细介绍如何在Python中实现单进程...
python线程安全及多进程多线程实现方法详解
09-18
Python中的线程安全和多进程多线程是并发编程中的重要概念，它们允许程序利用多核处理器的能力，提高系统的执行效率。线程安全是保证在多线程环境下，多个线程并发执行时不会出现数据不一致或竞态条件的问题。 线程...
python-多线程教程.pdf
02-05
- **多线程**：多线程是指在一个程序或进程中同时运行多个线程的技术。通过多线程，可以显著提高程序的性能和响应性。 #### 二、Python中的多线程支持 - **Python的标准库提供了两个模块**：`_thread` 和 `...
Python多进程同步之Join
Tokyo_2024的博客
12-06 463
1.应用场景：模块之间的顺序执行(模块内部无序) 2. 原理：Join会导致必须执行结束子进程之后再回到主进程执行，能有效设置子进程之间的模块的顺序性。 3. 测试源码： import multiprocessing import time def PrintNumber(vNum): time.sleep(10) num = 0 for i in range(1, 1000): for j in range(1, 1000): n
Python多线程（四）——join属性
重邮皮皮尛的博客
01-16 984
Python多线程之join()属性
Python - 多线程，多进程中的join和Event及没有使用join和event区别
Mr_WoLong
08-15 753
在Python的多线程和多进程编程中，`join()` 和 `Event` 都是用来控制线程或进程之间的同步关系的工具，它们的作用类似，但还是有一些区别。
pycharm64报错无法加载文件 E:\XXX\PycharmProjects\PythonStudy\venv\Scripts\activate.ps1
m0_65014849的博客
08-09 462
2、在windows上的Windows Powershall以管理员的身份运行，并在命令窗口输入set-executionpolicy remotesigned，输入Y，然后回车。，回车后可以看到Restricted。1、在工具的Terminal中输入。
python join堵塞后不运行主程序
最新发布
走向CTO的路上...
04-08 1034
方法对主程序的影响是阻塞其执行，直到被调用的对象执行完成。方法是Python中用于阻塞主程序的重要方法，它可以等待线程或进程执行完成后再继续主程序的执行。方法是Python中用于阻塞主程序的重要方法，可以实现多线程和多进程任务的同步和协调。方法实现线程或进程之间的同步，例如确保某个线程或进程在另一个线程或进程之前执行。方法的原理是通过阻塞主程序的执行，等待被调用对象的执行完成。方法会等待被调用对象（线程或进程）执行完毕后再继续主程序的执行。方法用于阻塞主程序的执行，直到指定的线程或进程完成执行。
python 中主线程结束 子线程还在运行么_python 线程之一：线程的创建、启动及运行方式
weixin_39843782的博客
11-22 273
threading：这个模块在较低级的模块 _thread 基础上建立较高级的线程接口以后我们就用 threading 模块来管理线程就可以了。Tread 类：控制线程创建、启动及运行方式一、线程的创建和启动(两种方法)from threading import Thread1、实例化 Thread 类的方式：定义一个任务(函数或方法)实例化 Thread 类，并传入函数名和参数start() 方...
python的threading.Thread线程的start、run、join、setDaemon
weixin_34362991的博客
11-28 1785
Pycharm整体看下Thread类的内容：模拟的是Java的线程模型   表示方法method，上面的锁头表示这个是类内部的方法，从方法名字命名规范可以看出，都是_和__开头的，一个下划线表示是子类可以继承，两个下划线表示是只有Thread内部可以访问，子类都不可以访问。 表示property，可以使用类直接访问：Thread._block 表示field，就是self.x定义的东东   表示...
while(Thread.activeCount() > 1)
weixin_34119545的博客
05-29 838
今天看到深入理解JVM第367页多线程volatile部分照着书本敲着代码发现了一个问题 Thread.activeCount()会一直大于2 public class VolatileTest { public static volatile int race = 0; public static void increase() { race++; } private stati...
python等待线程结束_python线程join
weixin_39606396的博客
11-27 2225
几个事实1 python 默认参数创建线程后，不管主线程是否执行完毕，都会等待子线程执行完毕才一起退出，有无join结果一样2 如果创建线程，并且设置了daemon为true，即thread.setDaemon(True), 则主线程执行完毕后自动退出，不会等待子线程的执行结果。而且随着主线程退出，子线程也消亡。3 join方法的作用是阻塞，等待子线程结束，join方法有一个参数是timeout，...
python创建新的线程/进程
05-26
在 Python 中，可以使用 `threading` 和 `multiprocessing` 模块来创建新的线程和进程。 1. 创建一个新线程： ```python import threading def my_function(): print("Running on a new thread") # 创建新线程 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值