开发面试题 dtcms文档 后端面试 pointers fonts configuration static 传智播客python pmp视频 nginx教程视频 git视频教程 matlab停止运行 内存计算 pyhton中异常和模块 python文件写入 python等待10秒 python安装模块 javasubstring java8函数式接口 java环境部署 java开发学习 java游戏开发 微信小程序提示框 idea重命名快捷键 millenium dll之家 一羽月土米水日古余打一成语 怎么设置迅雷为默认下载器 微信临时链接多久失效 电脑代码雨 虚拟声卡驱动 renderto vbs代码 珊瑚版 调试js 小米手环怎么连接手机 su镜像 调试工具 迅捷屏幕录像工具 cdr快捷键设置
当前位置: 首页 > 学习教程  > python

python_多任务编程

2021/2/7 9:55:33 文章标签: 测试文章如有侵权请发送至邮箱809451989@qq.com投诉后文章立即删除

多任务 多任务:在同一时间内执行多个任务 多任务的目的:多任务的最大好处是充分利用CPU资源,提高程序的执行效率 并发:在一段时间内交替执行多个任务 并行:在同一时刻同时执行多个任务 多进程(多任务的实现方式) 进程:运行中的…

多任务

多任务:在同一时间内执行多个任务
多任务的目的:多任务的最大好处是充分利用CPU资源,提高程序的执行效率
并发:在一段时间内交替执行多个任务
并行:在同一时刻同时执行多个任务

多进程(多任务的实现方式)

进程:运行中的程序,分配资源的最小单位
线程:使用资源的最小单位
进程和线程的关系:一个程序运行后至少有一个进程,每个进程默认有一个线程

多进程的使用流程:

  1. 导入进程模块(multiprocessing)

    import multiprocessing     
    
  2. 创建子进程对象

     sub_process = multiprocessing.Process(group=None, target=None, name=None, args, kwargs)
     # 其中:args 方式传参应注意参数顺序一致,kwargs 传参应注意字典的 key 与参数名一致
    
  3. 启动子进程

     sub_process.start() #启动子进程
     sub_process.join() # 进程等待
     sub_process.terminate() # 终止子进程
     multiprocessing.current_process() #查看当前进程
     os.getpid() # 查看进程编号
     os.getppid() # 查看父进程编号
     os.kill(进程编号,9) # 根据进程编号强制杀死进程
     print(a, b, c) # 可以直接打印变量 a b c
    
     # 进程的运行是无序的,不依赖代码的先后顺序
    

实例:

# 单进程
import time


def dance():
    for i in range(5):
        time.sleep(1)
        print("DANCE", i)


def sing():
    for i in range(5):
        time.sleep(1)
        print("SING", i)


if __name__ == '__main__':
    dance()
    sing()

[运行结果]
[Done] exited with code=0 in 10.052 seconds

# 多进程
import time

# 导入进程模块
import multiprocessing


def dance():
    for i in range(5):
        time.sleep(1)
        print("DANCE", i)


def sing():
    for i in range(5):
        time.sleep(1)
        print("SING", i)


if __name__ == '__main__':
    # 创建子进程
    my_dance = multiprocessing.Process(target=dance)
    my_sing = multiprocessing.Process(target=sing)

    # 启动子进程
    my_dance.start()
    my_sing.start()

[运行结果]
[Done] exited with code=0 in 5.095 seconds

进程ID(os模块)

目的: 知道子进程是由哪个主进程创建的(子进程需要主进程回收资源)
os.getpid(): 表示获取当前进程编号
os.getppid(): 表示获取当前父进程编号

进程名字

  1. 进程起名字

     my_dance = multiprocessing.Process(target=dance, name="my_ProcessName")
    
  2. 获取进程的名字

     multiprocessing.current_process()
    
     # 运行结果
     <Process name='my_ProcessName' parent=151225 started>
    

进程参数

带有参数的函数:
args: 元组!!!(单个元素的元组有 , )
my_dance = multiprocessing.Process(target=dance, args=(5,))
	
kwargs: 字典!!!(key值要和函数中的形参完全重名)
my_dance = multiprocessing.Process(target=dance, kwargs={"count": 5})

进程之间不共享全局变量

进程之间不共享全局变量,是因为操作的不是同一个进程里面的全局变量,只不过不同进程里面的全局变量名字相同而已

import multiprocessing
import time

# 全局变量列表
g_num = []

def my_write(): # 向全局变量g_num里写入数据
    global g_num
    for i in range(5):
        g_num.append(i)
    print("my_write:", g_num)


def my_read(): #读取全局变量g_num的值
    global g_num
    print("my_read:", g_num)


if __name__ == '__main__':
    sub_write = multiprocessing.Process(target=my_write)
    sub_read = multiprocessing.Process(target=my_read)

    sub_write.start()
    time.sleep(1) # 保证数据写入g_num中
    sub_read.start()

[运行结果]
my_write: [0, 1, 2, 3, 4]
my_read: []

守护主进程or销毁子进程

为了保证子进程能够正常的运行,主进程会等所有的子进程执行完成以后再销毁
设置守护主进程或销毁主进程的目的是主进程退出子进程销毁,不让主进程再等待子进程去执行

  • 设置守护主进程: 子进程对象.daemon = True
  • 销毁子进程: 子进程对象.terminate()

多线程(多任务的实现方式)

多线程使用流程

  1. 导入线程模块(threading)
  2. 创建子线程
  3. 开始子线程

实例

import time

# 导入线程模块
import threading


def dance():
    for i in range(5):
        time.sleep(1)
        print("DANCE", i)


def sing():
    for i in range(5):
        time.sleep(1)
        print("SING", i)


if __name__ == '__main__':
    # 创建子进程
    my_dance = threading.Thread(target=dance)
    my_sing = threading.Thread(target=sing)

    # 启动子进程
    my_dance.start()
    my_sing.start()

[运行结果]
[Done] exited with code=0 in 5.042 seconds

线程之间是无序执行的

守护主线程

主线程会等待子线程的结束而结束
设置守护主线程的两种方式:

  • threading.Thread(target=show_info, daemon=True)
  • 线程对象.setDaemon(True)

线程参数(同进程)

线程之间共享全局变量

好处是可以对全局变量的数据进行共享
但是可能会导致数据出现错误问题

import threading
import time

g_num = []


def my_write():
    global g_num
    for i in range(5):
        g_num.append(i)
    print("my_write:", g_num)


def my_read():
    global g_num
    print("my_read:", g_num)


if __name__ == '__main__':
    sub_write = threading.Thread(target=my_write)
    sub_read = threading.Thread(target=my_read)

    sub_write.start()
    time.sleep(1)
    sub_read.start()

[运行结果]
my_write: [0, 1, 2, 3, 4]
my_read: [0, 1, 2, 3, 4]

线程之间共享全局变量的问题

线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调,按预定的先后次序进行运行。
线程同步的方式:

  • 线程等待(join)

      first_thread.start()
      first_thread.join() # 等待线程first_thread执行完毕再继续向下进行
      second_thread.start()    
    
  • 互斥锁
    对共享数据进行锁定,保证同一时刻只能有一个线程去操作
    互斥锁的使用:

    • 创建锁:mutex = threading.Lock()
    • 上锁:mutex.acquire()
    • 释放锁:mutex.release()
      注意避免死锁,在合适位置释放锁

本文链接: http://www.dtmao.cc/news_show_2000205.shtml

附件下载

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?