高级应用：进程和线程的补充

最新推荐文章于 2024-07-23 17:34:00 发布
最新推荐文章于 2024-07-23 17:34:00 发布
阅读量109 收藏
点赞数 2
分类专栏： 高级编程 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70750879/article/details/125744374
版权

 

一：多任务运行控制

1.1 join 方法：

join 方法：进程或者线程添加join方法之后，会等 主进程待子任务结束，如果没有结束则会阻塞， 直到子按任务结束，因此join一般都是 放在程序的最后面

        eg：关闭浏览器，会提示是否关闭所有界面。

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(5)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    p1.join()       #主任务等待子任务结束在结束
    print('外部开始时间',new_time())

       

1.2终止任务

     终止任务： 在正常情况下，主进程的结束，并不会影响子进程，但是也可以在主进程结束之后，强制终止子进程

        注意：线程不能终止，只能等待结束

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(5)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    # p1.join()
    p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

1.3 join和terminate 在开发时的判断

import time
import multiprocessing

#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    res = input('是否继续执行子任务N/Y')
    if res == 'Y':  #主进程等待子进程运行结束后在结束
        p1.join()
    elif res =='N':
        p1.terminate()
    else:
        print('请输入准确的指令')
    # p1.join()
    # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

二：获取当前进程：

        2.1 获取当前进程对象：multiprocessing.current_process()

        作用：很方便的看到每个进程出现的问题

import time
import multiprocessing

print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    p1.start()
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

         2.2 获取进程pid 

        作用：在代码的书写，软件的开发，用的Linux 系统中，知道进程的pid之后，用 kill 命令可以杀掉当前的进程的方法

import time
import multiprocessing

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 =multiprocessing.Process(target=func) #子进程：内部开始时间
    print('before_start',p1.pid)
    p1.start()
    print('after_start', p1.pid)
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

 2.3 获取线程 ident

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func)  #实例化对象
    print('before_start',p1.ident)  #获取线程ident
    p1.start()    #开启新的线程 ——子线程
    print('after_start', p1.ident)
    time.sleep(5)  #主进程休眠
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

三：生命周期

        3.1  进程的生命周期开始于start，实例化之后，进 程并没有启动，只有启动之后才开始生命周期  is_alive

        作用：查看进程有没有在做事情，在做事情则是Ture 否则False

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func)#子进程：内部开始时间
    print('before_start',p1.is_alive())
    p1.start()
    print('after_start', p1.is_alive())
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

四：守护模式

        开启守护模式之后，主进程结束，子进 程会自动结束。他的写法的是在进程实例化对象中添加 daemon = Ture

        守护模式跟terminate的区别：

                共同点：主进程结束之后，强制终止子进程

                不同点：守护模式是殉情模式（自杀），terminate是他杀（谋杀）

import time
import multiprocessing
import threading

# print(multiprocessing.current_process())  #获取当前进程对象
#现在时间方法：
def new_time():
    return time.strftime('%Y-%m-%d %H:%M:%S')

def func():
    print('内部开始时间',new_time())
    # print(multiprocessing.current_process())
    time.sleep(10)
    print('内部开始时间',new_time())

if __name__ == '__main__':
    print('外部开始时间',new_time())
    p1 = threading.Thread(target=func,daemon=True)# 守护模式开始
    # print('before_start',p1.is_alive())
    p1.start()
    # print('after_start', p1.is_alive())
    time.sleep(5)
    # res = input('是否继续执行子任务N/Y')
    # if res == 'Y':  #主进程等待子进程运行结束后在结束
    #     p1.join()
    # elif res =='N':
    #     p1.terminate()
    # else:
    #     print('请输入准确的指令')
    # # p1.join()
    # # p1.terminate()  #强制终止子进程
    print('外部开始时间',new_time())

附加：

补充上节课没讲完知识点：

进程注意点：1.进程之间执行是无序的 ，进程是由操作系统决定，操作系统调用哪个进程，哪个进程就会执行，没有调用的就不执行。  2.进程之间不共享全局变量  3.主进程程会等待所有的子进程执行结束再结束。

线程注意点：1.线程之间执行是无序的 ，它是由CPU调度决定的，CPU调用的哪个线程，哪个线程就会执行。没有调度的就不能执行 2.主线程会等待所有的子线程执行结束再结束  3.线程之间共享全局变量 

拓展功能：面向对象编程和进程和线程的结合使用

redis：

 拓展：

在终端切换硬盘：D:

切换到那个路径下面:   cd+文件名

查看文件夹有哪些目录：  ls

杨某人...
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
完整word版-Android高级应用课程标准.doc
11-25
【Android高级应用课程标准】 本课程为Android高级开发的核心课程，专为计算机及软件技术相关专业的学生设计，基于Java方向，旨在深化学生对Android技术的理解，特别是高级API的使用。课程通过理论与实践相结合的...
Linux高级程序设计中文第三版.pdf
02-21
网络编程是现代应用程序不可或缺的一部分，本书对此进行了详细介绍，包括套接字编程、TCP/IP协议栈、多线程和异步I/O，使读者能够构建网络服务器和客户端应用。 除此之外，书中还涉及了信号处理、进程间通信（IPC）...
进程Process之join、daemon(守护)、terminate(关闭)
weixin_30713953的博客
12-09 527
一、Process 参数介绍： 1 group参数未使用，值始终为None 2 target表示调用对象，即子进程要执行的任务 3 args表示调用对象的位置参数元组，args=(1,2,'a',) 4 kwargs表示调用对象的字典,kwargs={'name':'a','age':18} 5 name为子进程的名称 方法介绍： 1 p.start()：启动进...
Python进程池Pool：让每个进程井然有序
微小冷的学习笔记
12-05 2045
如果疯狂地弹进程，很容易导致内存爆炸，所以非常有必要设计一种功能，可以限定同时运行的进程数，这就是进程池。
进程和线程的区别
热门推荐
qq_40855100的博客
12-18 1万+
转自文章进程和线程的区别 1、根本区别 进程和线程的根本区别是进程是操作系统资源（OS）分配的基本单位，而线程是处理器（CPU）任务调度和执行的基本单位。 2、资源开销： 每个进程都有独立的代码和数据空间（程序上下文）,程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC),线程之间切换的开销小。 3、包含关系： 如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线 同完成的；线程是进程的一部分，所行过程不愿一条绿的，而
王道操作系统笔记（二）—— 进程与线程
秀岩的博客
01-14 1384
一、进程的概念和特征 1.1 进程的概念 1.2 进程的组成 1.3 进程的特征 1.4 进程的状态与转换 1.5 进程控制 1.6 进程的通信 1.6.1 共享存储 1.6.2 消息传递 1.6.3 管道通信 1.7 父进程与子进程 二、线程概念和多线程模型 2.1 线程的概念 2.2 线程的属性 2.3 线程的实现方式 2.4 多线程模型 2.5 线程的状态与转换 2.6 线程的组织与控制
OS之进程和线程
BDS的朝圣路
05-28 749
程序是指一组指令的集合，它是静态的、存储在磁盘或其他存储介质上的代码。程序本身并没有在计算机上执行，只有在被加载到内存并由操作系统调度执行时，才成为一个活动的实体。
linux编程及应用-任继平补充shell编程.ppt
09-28
4. **线程与线程同步**：线程是轻量级的进程，涉及到线程的创建、销毁、同步（互斥锁、读写锁、条件变量和信号灯）以及信号处理。 5. **网络编程**：涵盖TCP/IP协议、socket编程、连接建立与断开、数据传输、错误...
python从入门到高级学习笔记
03-23
在Python中，你可以使用os和multiprocessing模块创建和管理进程，利用threading模块进行线程操作。笔记会解释这些概念，并提供关于线程同步（如锁、信号量）和进程间通信（IPC）的示例。 正则表达式（regex）是处理...
简单关掉进程<进程杀手>
03-26
7. **知识补充**：了解基础的进程管理知识也很重要，例如进程和线程的区别，进程的优先级，以及如何通过任务管理器（Task Manager）手动管理进程等。这样在没有“进程杀手”等工具的情况下，也能有效地维护系统性能...
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 184
zookeeper安装并成功运行。
数据分析师学习路线与就业环境分析报告
关注收藏，可以私信解决问题！
07-23 537
数据分析师负责收集、处理和分析数据，以帮助企业做出基于数据的决策。他们使用统计方法、数据建模和数据可视化技术来解释复杂的数据集。
江苏科技大学24计算机考研数据速览，有专硕复试线大幅下降67分！
最新发布
m0_72717598的博客
07-23 194
江苏科技大学（Jiangsu University of Science and Technology），坐落在江苏省镇江市，是江苏省重点建设高校，江苏省人民政府与中国船舶集团有限公司共建高校，国家国防科技工业局与江苏省人民政府共建高校 ，教育部卓越工程师教育培养计划高校，教育部本科教学工作水平评估优秀学校，江苏省高水平大学建设高峰计划B类建设高校，中国船舶与海洋工程产业知识产权联盟、江苏船舶与海洋类高校协同发展联盟牵头单位。其中，研究生新生学业奖学金特等奖3万，一等奖1.2万，二等奖0.8万；
Kudu节点数规划
07-19 599
由于Kudu是Hadoop生态的一部分（虽然它不依赖于Hadoop生态系统），因此大多数实际应用场景需要的不仅仅是Kudu；为了输入数据，可能需要Kafka、StreamSets或Spark Streaming；对于机器学习和数据处理，可能需要Spark；对于交互式SQL，我们也肯定想要Impala。实际上，Kudu和Hadoop生态系统紧密低集成正是其优势之一，因此我们很少单独使用Kudu，所以，在讨论Kudu集群规划时，一般不仅仅是考虑到Kudu。
科普文：搭建信贷业务大数据风控体系
为无为，事无事，味无味。
07-22 559
大家好，本期为大家介绍如何从0到1搭建大数据风控体系。分为：获客、贷前、贷中、贷后、主要数据维度，以及如何识别风险客户。
提高性能的常见技术
thebgt的博客
07-23 111
1.数据库层面：
Java高级基础：Swing, GUI, 数据库优化与网络编程
这篇内容主要涵盖了Java高级基础概念，包括图形用户界面、事件处理、数据库优化、泛型、日期格式化、容器类、网络编程以及正则...这些知识点构成了Java高级开发的基础，对于理解和构建复杂的Java应用程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨某人...

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值