草庐IT

Python多任务教程

小小程序员ol 2023-03-28 原文

一.并发和并行

  1. 多任务:一定时间段内,充分利用cpu资源,同时去执行多个任务

  2. 并发: 快速交替的 去执行多任务

  3. 并行: 真正同时的 去执行多任务 ,就是同时进行

二.多进程

1.多进程入门

知识点:

  1. 进程含义: 运行中的程序

  2. 进程特点: cpu资源分配的 最小单位

  3. 多进程模块: multiprocessing

  4. 进程类: Process

使用步骤:

  1. 导包 : import multiprocessing

  2. 创建对象 : 子进程对象 = multiprocessing.Process(target=任务名)

  3. 开启进程 : 子进程对象.start()

示例:

import multiprocessing
import time
# 任务1
def dance():
    for i in range(5):
        time.sleep(0.1)
        print('跳舞',i)
# 任务2
def sing():
    for i in range(5):
        time.sleep(0.3)
        print('唱歌',i)
# 多进程放到main内
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=dance)
    p2 = multiprocessing.Process(target=sing)
    # 2.开启进程
    p1.start()
    p2.start()

2.os模块获取进程编号

知识点:

获取当前进程id: os.getpid()   pid: processing id

获取父进程id: os.getppid()   ppid: parent processing id

示例:

import multiprocessing
import os
import time
# 任务1
def dance():
    print('dance子进程:', os.getpid(), os.getppid())
    for i in range(5):
        time.sleep(0.1)
        print('跳舞',i)
# 任务2
def sing():
    print('sing子进程:', os.getpid(),os.getppid())
    for i in range(5):
        time.sleep(0.3)
        print('唱歌',i)
# 多进程放到main内
if __name__ == '__main__':
    print('main主进程:',os.getpid())
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=dance)
    p2 = multiprocessing.Process(target=sing)
    # 2.开启进程
    p1.start()
    p2.start()

3.Process()类的传参,2种方式

知识点:

  • args: 以元组方式传参 注意:如果只有一个参数需要加逗号, 如果多个参数顺序要任务参数顺序一致

  • kwargs: 以字典方式传参 注意:需要{k:v}形式传参,k必须和任务的形参名一致

示例:

import multiprocessing
import os
import time
# 任务1
def dance(num):
    print('dance子进程:', os.getpid(), os.getppid())
    for i in range(num):
        time.sleep(0.1)
        print('跳舞',i)
# 任务2
def sing(num):
    print('sing子进程:', os.getpid(), os.getppid())
    for i in range(num):
        time.sleep(0.3)
        print('唱歌',i)
# 多进程放到main内
if __name__ == '__main__':
    print('main主进程:', os.getpid())
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=dance,args=(5,))
    p2 = multiprocessing.Process(target=sing,kwargs={'num':5})
    # 2.开启进程
    p1.start()
    p2.start()

4.获取当前进程信息

知识点:

  1. 获取当前进程对象: multiprocessing.current_process()

  2. 获取当前进程name: multiprocessing.current_process().name

  3. 获取当前进程pid: multiprocessing.current_process().pid

示例:

import multiprocessing
# 任务1
def dance():
    print('dance子进程对象:', multiprocessing.current_process())
    print('dance子进程name:', multiprocessing.current_process().name)
    print('dance子进程id:', multiprocessing.current_process().pid)

# 任务2
def sing():
    print('sing子进程对象:', multiprocessing.current_process())
    print('sing子进程name:', multiprocessing.current_process().name)
    print('sing子进程id:', multiprocessing.current_process().pid)

# 多进程放到main内
if __name__ == '__main__':
    print('main主进程对象:', multiprocessing.current_process())
    print('main主进程name:', multiprocessing.current_process().name)
    print('main主进程id:', multiprocessing.current_process().pid)
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=dance,name='danceProcess')
    p2 = multiprocessing.Process(target=sing,name='singProcess')
    # 2.开启进程
    p1.start()
    p2.start()

5.注意事项

1. 多进程间不能共享全局变量:

import multiprocessing

mylist = []
# 写
def write():
    global mylist
    mylist = [1,2,3,4,5]
    print('write:',mylist) # [1, 2, 3, 4, 5]
# 读
def read():
    global mylist
    print('read:',mylist)  # []  说明多个进程间不共享全局变量

# 多进程需要放到main内
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=write)
    p2 = multiprocessing.Process(target=read)
    # 2.开启进程
    p1.start()
    p2.start()

2. 主进程默认等待子进程结束再结束:

import multiprocessing
import time


# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=task)
    # 2.开启进程
    p1.start()

    # 3.主进程等待0.5秒
    time.sleep(0.5)
    print('主进程中最后一行代码....')

2. 主进程默认等待子进程结束再结束:

import multiprocessing
import time


# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=task)
    # 2.开启进程
    p1.start()

    # 3.主进程等待0.5秒
    time.sleep(0.5)
    print('主进程中最后一行代码....')

3. 多进程执行是无序的:

import multiprocessing
import time

# 任务
def show():
    time.sleep(2)
    print(multiprocessing.current_process().name)
# 学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
# 多任务
if __name__ == '__main__':
    for _ in range(5):
        # 创建进程对象
        p = multiprocessing.Process(target=show)
        # 开启进程
        p.start()

6.设置子进程跟着主进程一起结束#

知识点:

方式1 设置子进程守护主进程:  子进程对象.daemon = True   注意: 需要在开启进程之前设置   

       :                          daemon/ˈdiːmən/守护进程


方式2 手动销毁子进程     :  子进程对象.terminate()    terminate:结束,终止

1. 守护主进程:

import multiprocessing
import time


# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=task)
    # 方式1: 开启子进程之前设置守护主进程
    p1.daemon = True
    # 2.开启进程
    p1.start()


    # 3.主进程等待0.5秒
    time.sleep(0.5)
    print('主进程中最后一行代码....')

2. 手动销毁子进程:

import multiprocessing
import time


# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建进程对象
    p1 = multiprocessing.Process(target=task)

    # 2.开启进程
    p1.start()

    # 3.主进程等待0.5秒
    time.sleep(0.5)
    print('主进程中最后一行代码....')
    
    # 方式2: 手动销毁子进程
    p1.terminate()

三.多线程

1.多线程入门

知识点:

  1. 线程含义: 进程中 执行代码的 一个分支 (一个进程至少有一个线程)

  2. 线程作用: 线程是 cpu调度的 最小单位

  3. 多线程模块: threading

  4. 线程类: Thread

使用步骤:

  1. 导包 : import threading
  2. 创建对象 : 子线程对象 = threading.Thread(target=任务名)
  3. 开启进程 : 子线程对象.start()

示例:

import threading


# 任务1
def dance():
    for i in range(5):
        print('跳舞',i)
# 任务2
def sing():
    for i in range(5):
        print('唱歌',i)

# 多任务
if __name__ == '__main__':
    # 1.创建子线程对象
    t1 = threading.Thread(target=dance)
    t2 = threading.Thread(target=sing)
    # 2.开启线程
    t1.start()
    t2.start()

2.多线程的传参

知识点:

args: 以元组方式传参 注意:如果只有一个参数需要加逗号, 如果多个参数顺序要任务参数顺序一致

kwargs: 以字典方式传参 注意:需要{k:v}形式传参,k必须和任务的形参名一致

与多进程一模一样

示例:

import threading
"""
args: 以元组方式传参   注意:如果只有一个参数需要加逗号, 如果多个参数顺序要任务参数顺序一致
kwargs: 以字典方式传参  注意:需要{k:v}形式传参,k必须和任务的形参名一致
"""
# 任务1
def dance(num):
    for i in range(num):
        print('跳舞', i)

# 任务2
def sing(num):
    for i in range(num):
        print('唱歌', i)

# 多任务
if __name__ == '__main__':
    # 1.创建子线程对象
    t1 = threading.Thread(target=dance,args=(5,))
    t2 = threading.Thread(target=sing,kwargs={'num':5})
    # 2.开启线程
    t1.start()
    t2.start()

3.多线程注意事项

  1. 多线程是在一个进程中
import os
import threading
"""
args: 以元组方式传参   注意:如果只有一个参数需要加逗号, 如果多个参数顺序要任务参数顺序一致
kwargs: 以字典方式传参  注意:需要{k:v}形式传参,k必须和任务的形参名一致
"""
# 任务1
def dance(num):
    print(f'dance子线程中当前进程pid:{os.getpid()}')
    for i in range(num):
        print('跳舞', i)

# 任务2
def sing(num):
    print(f'sing子线程中当前进程pid:{os.getpid()}')
    for i in range(num):
        print('唱歌', i)

# 多任务
if __name__ == '__main__':
    print(f'main主线程中当前进程pid:{os.getpid()}')
    # 1.创建子线程对象
    t1 = threading.Thread(target=dance,args=(5,))
    t2 = threading.Thread(target=sing,kwargs={'num':5})
    # 2.开启线程
    t1.start()
    t2.start()

2. 多线程是可以共享全局变量

import threading

mylist = []
# 写
def write():
    global mylist
    mylist = [1,2,3,4,5]
    print('write:',mylist) # [1, 2, 3, 4, 5]
# 读
def read():
    global mylist
    print('read:',mylist)  # [1, 2, 3, 4, 5] 访问到了write线程修改后的内容说明多线程共享全局变量

if __name__ == '__main__':
    # 1.创建线程对象
    t1 = threading.Thread(target=write)
    t2 = threading.Thread(target=read)
    # 2.开启线程
    t1.start()
    t2.start()

3. 主线程默认等待子线程结束再结束

import threading
import time

# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建线程对象
    t = threading.Thread(target=task)
    # 2.开启线程
    t.start()

    # 3.为了效果明显点,主线程等待0.5秒
    time.sleep(0.5)
    print('主线程中最后一行代码....')

4. 多线程是无序的

import threading
import time

# 任务
def show():
    time.sleep(1)
    print(threading.current_thread().name)

# 多任务
if __name__ == '__main__':
    for _ in range(5):
        # 创建线程对象
        p = threading.Thread(target=show)
        # 开启线程
        p.start()

4.设置守护主线程

知识点:

方式1: daemon属性        t.daemon = True       daemon/ˈdiːmən/守护进程
    
方式2: setDaemon()方法   t.setDaemon(True)

一个是属性,一个是方法,用哪个都可以

示例:

import threading
import time

# 任务
def task():
    for i in range(10):
        print('任务进行中...')
        time.sleep(0.2)

# 多任务
if __name__ == '__main__':
    # 1.创建线程对象
    t = threading.Thread(target=task)
    
    # 方式1: daemon属性
    # t.daemon = True

    # 方式2: setDaemon()方法
    t.setDaemon(True)
    # 2.开启线程
    t.start()

    # 3.为了效果明显点,主线程等待0.5秒
    time.sleep(0.5)
    print('主线程中最后一行代码....')

5.获取当前线程信息

知识点:

  1. 获取当前线程对象:threading.current_thread()

  2. 获取当前线程name:threading.current_thread().name

  3. 获取当前线程id:threading.current_thread().native_id

示例:

import threading

def dance():
    print(f'dance当前线程对象:{threading.current_thread()}')
    print(f'dance当前线程name:{threading.current_thread().name}')
    print(f'dance当前线程id:{threading.current_thread().native_id}')

def sing():
    print(f'sing当前线程对象:{threading.current_thread()}')
    print(f'sing当前线程name:{threading.current_thread().name}')
    print(f'sing当前线程id:{threading.current_thread().native_id}')


if __name__ == '__main__':
    print(f'main当前线程对象:{threading.current_thread()}')
    print(f'main当前线程name:{threading.current_thread().name}')
    print(f'main当前线程id:{threading.current_thread().native_id}')

    # 1.创建线程对象
    t1 = threading.Thread(target=dance,name='DanceThread')
    t2 = threading.Thread(target=sing,name='SingThread')
    # 2.开启线程
    t1.start()
    t2.start()

6.线程安全问题

1. 出现的线程安全问题:

import threading

sum = 0

def sum1():
    global sum
    for i in range(1000000):
        sum += 1
    print(sum) # 1114834

def sum2():
    global sum
    for i in range(1000000):
        sum += 1
    print(sum)  # 1339347

# 单任务不会出现问题 正常结果  1000000 2000000
# 多任务出现了问题
if __name__ == '__main__':
    # 1.创建线程对象
    t1 = threading.Thread(target=sum1)
    t2 = threading.Thread(target=sum2)
    # 2.开启线程
    t1.start()
    t2.start()

2. 锁机制解决线程安全问题:

import threading

sum = 0

def sum1(lock):
    lock.acquire() # 加锁
    global sum
    for i in range(1000000):
        sum += 1
    print(sum) # 1000000
    lock.release() # 释放锁

def sum2(lock):
    lock.acquire()  # 加锁
    global sum
    for i in range(1000000):
        sum += 1
    print(sum)  # 2000000
    lock.release()  # 释放锁

# 单任务不会出现问题 正常结果  1000000 2000000
# 多任务出现了问题 ,利用锁机制解决问题
if __name__ == '__main__':
    # 创建一个锁,保证两个任务用的是同一个锁
    lock= threading.Lock()
    # 1.创建线程对象
    t1 = threading.Thread(target=sum1,args=(lock,))
    t2 = threading.Thread(target=sum2,args=(lock,))
    # 2.开启线程
    t1.start()
    t2.start()

3. join解决线程安全问题:

import threading

sum = 0


def sum1():
    global sum
    for i in range(1000000):
        sum += 1
    print(sum)  # 1000000

def sum2():
    global sum
    for i in range(1000000):
        sum += 1
    print(sum)  # 2000000
# 学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
# 单任务不会出现问题 正常结果  1000000 2000000
# 多任务出现了问题 ,利用join解决问题
if __name__ == '__main__':
    # 1.创建线程对象
    t1 = threading.Thread(target=sum1)
    t2 = threading.Thread(target=sum2)
    # 2.开启线程
    t1.start()
    t1.join()  # t1线程告诉其他线程等我执行完,你们其他线程再执行

    t2.start()

四.进程和线程对比

关系

  1. 线程是依附在进程里面的，没有进程就没有线程

  2. 一个进程默认提供一条线程，进程可以创建多个线程

区别

  1. 进程之间不共享全局变量
  2. 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法是互斥锁或者线程同步
  3. 创建进程的资源开销要比创建线程的资源开销要大
  4. 进程是操作系统 资源分配 的基本单位，线程是 CPU调度 的基本单位
  5. 线程不能够独立执行，必须依存在进程中
  6. 多进程开发比单进程多线程开发稳定性要强

优缺点

进程优缺点:
优点：可以用多核
缺点：资源开销大

线程优缺点:
优点：资源开销小
缺点：不能使用多核

Python多任务multiprocessingthreadingprint

有关Python多任务教程的更多相关文章

  1. ruby - 其他文件中的 Rake 任务 - 2

    我试图在一个项目中使用rake，如果我把所有东西都放到Rakefile中，它会很大并且很难读取/找到东西，所以我试着将每个命名空间放在lib/rake中它自己的文件中，我添加了这个到我的rake文件的顶部:Dir['#{File.dirname(__FILE__)}/lib/rake/*.rake'].map{|f|requiref}它加载文件没问题，但没有任务。我现在只有一个.rake文件作为测试，名为“servers.rake”，它看起来像这样:namespace:serverdotask:testdoputs"test"endend所以当我运行rakeserver:testid时

  2. python - 如何使用 Ruby 或 Python 创建一系列高音调和低音调的蜂鸣声？ - 2

    关闭。这个问题是opinion-based.它目前不接受答案。想要改进这个问题？更新问题，以便editingthispost可以用事实和引用来回答它.关闭4年前。Improvethisquestion我想在固定时间创建一系列低音和高音调的哔哔声。例如:在150毫秒时发出高音调的蜂鸣声在151毫秒时发出低音调的蜂鸣声200毫秒时发出低音调的蜂鸣声250毫秒的高音调蜂鸣声有没有办法在Ruby或Python中做到这一点？我真的不在乎输出编码是什么(.wav、.mp3、.ogg等等)，但我确实想创建一个输出文件。

  3. ruby - 如何使用 RSpec::Core::RakeTask 创建 RSpec Rake 任务？ - 2

    如何使用RSpec::Core::RakeTask初始化RSpecRake任务？require'rspec/core/rake_task'RSpec::Core::RakeTask.newdo|t|#whatdoIputinhere?endInitialize函数记录在http://rubydoc.info/github/rspec/rspec-core/RSpec/Core/RakeTask#initialize-instance_method没有很好的记录；它只是说:-(RakeTask)initialize(*args,&task_block)AnewinstanceofRake

  4. Python 相当于 Perl/Ruby ||= - 2

    这个问题在这里已经有了答案:关闭10年前。PossibleDuplicate:Pythonconditionalassignmentoperator对于这样一个简单的问题表示歉意，但是谷歌搜索||=并不是很有帮助；)Python中是否有与Ruby和Perl中的||=语句等效的语句？例如:foo="hey"foo||="what"#assignfooifit'sundefined#fooisstill"hey"bar||="yeah"#baris"yeah"另外，类似这样的东西的通用术语是什么？条件分配是我的第一个猜测，但Wikipediapage跟我想的不太一样。

  5. java - 什么相当于 ruby​​ 的 rack 或 python 的 Java wsgi？ - 2

    什么是ruby​​的rack或python的Java的wsgi？还有一个路由库。 最佳答案 来自Python标准PEP333:Bycontrast,althoughJavahasjustasmanywebapplicationframeworksavailable,Java's"servlet"APImakesitpossibleforapplicationswrittenwithanyJavawebapplicationframeworktoruninanywebserverthatsupportstheservletAPI.ht

  6. 华为OD机试用Python实现 -【明明的随机数】 2023Q1A - 2

    华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o

  7. python - 如何读取 MIDI 文件、更改其乐器并将其写回？ - 2

    我想解析一个已经存在的.mid文件，改变它的乐器，例如从“acousticgrandpiano”到“violin”，然后将它保存回去或作为另一个.mid文件。根据我在文档中看到的内容，该乐器通过program_change或patch_change指令进行了更改，但我找不到任何在已经存在的MIDI文件中执行此操作的库.他们似乎都只支持从头开始创建的MIDI文件。 最佳答案 MIDIpackage会为您完成此操作，但具体方法取决于midi文件的原始内容。一个MIDI文件由一个或多个音轨组成，每个音轨是十六个channel中任何一个上的

  8. 「Python｜Selenium｜场景案例」如何定位iframe中的元素？ - 2

    本文主要介绍在使用Selenium进行自动化测试或者任务时，对于使用了iframe的页面，如何定位iframe中的元素文章目录场景描述解决方案具体代码场景描述当我们在使用Selenium进行自动化测试的时候，可能会遇到一些界面或者窗体是使用HTML的iframe标签进行承载的。对于iframe中的标签，如果直接查找是无法找到的，会抛出没有找到元素的异常。比如近在咫尺的例子就是，CSDN的登录窗体就是使用的iframe，大家可以尝试通过F12开发者模式查看到的tag_name,class_name,id或者xpath来定位中的页面元素，会抛出NoSuchElementException异常。解决

  9. postman接口测试工具-基础使用教程 - 2

    1.postman介绍Postman一款非常流行的API调试工具。其实，开发人员用的更多。因为测试人员做接口测试会有更多选择，例如Jmeter、soapUI等。不过，对于开发过程中去调试接口，Postman确实足够的简单方便，而且功能强大。2.下载安装官网地址:https://www.postman.com/下载完成后双击安装吧，安装过程极其简单，无需任何操作3.使用教程这里以百度为例,工具使用简单，填写URL地址即可发送请求，在下方查看响应结果和响应状态码常用方法都有支持请求方法:getpostputdeleteGet、Post、Put与Delete的作用get：请求方法一般是用于数据查询，

  10. 在VMware16虚拟机安装Ubuntu详细教程 - 2

    在VMware16.2.4安装Ubuntu一、安装VMware1.打开VMwareWorkstationPro官网，点击即可进入。2.进入后向下滑动找到Workstation16ProforWindows，点击立即下载。3.下载完成，文件大小615MB，如下图：4.鼠标右击，以管理员身份运行。5.点击下一步6.勾选条款，点击下一步7.先勾选，再点击下一步8.去掉勾选，点击下一步9.点击下一步10.点击安装11.点击许可证12.在百度上搜索VM16许可证，复制填入，然后点击输入即可，亲测有效。13.点击完成14.重启系统，点击是15.双击VMwareWorkstationPro图标，进入虚拟机主

随机推荐