线程与进程概念

最新推荐文章于 2024-01-15 17:33:23 发布

超锅锅教你敲代码

最新推荐文章于 2024-01-15 17:33:23 发布

阅读量63

点赞数

文章标签： python 线程进程多任务

本文链接：https://blog.csdn.net/kaadasd/article/details/98852677

版权

1 .多任务

同一时间执行多个任务，可以同时间运行多个任务
执行方式：
- 并发：交替执行任务
  - 单核处理多任务，操作系统让各个软件交替执行，软件1 执行0.01秒，切换到软件2执行0.01秒，再切换到软件三，执行0.01秒
- 并行：多核cpu处理多任务，操作系统会给cpu每个内核安排执行软件，多个内核一起执行软件。
  - 优点：使用多任务充分利用cpu资源，提高程序执行效率，让程序具备处理多任务能力

2. 进程

一个正在运行程序或软件是一个进程，是操作系统进行资源分配的基本单位，每启动一个进程，系统会给其分配一定内存资源
- 例子：公司理解一个进程，公司提供办公资源（电脑、桌椅），员工理解线程。
进程是实现多任务一种方式
一个程序至少一个进程，一个进程默认有一个线程，进程里可以创建多个线程，线程依附正在进程里面。
进程之间不共享全局变量：

2.1Process进程类说明

Process([group [, target [, name [, args [, kwargs]]]]])
- group：指定进程组，目前只能使用None
- target：执行的目标任务名
- name：进程名字
- args：以元组方式给执行任务传参
- kwargs：以字典方式给执行任务传参
总结：
1. 导入进程包
  - import multiprocessing
2. 创建子进程并指定执行的任务
  - sub_process = multiprocessing.Process (target=任务名)
3. 启动进程执行任务
  - sub_process.start()

2.2 获取进程编号目的

验证主进程和子进程关系，得知子进程由哪个主进程创建来的

获取进程编码操作

获取当前进程编号（使用os.getpid()）

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果:

main: 70763
main: <_MainProcess(MainProcess, started)>
dance: 70768
dance: <Process(myprocess1, started)>
跳舞中...
sing: 70769
sing: <Process(Process-2, started)>
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

获取当前父进程编号 os.getppid()

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
    
    
    
# -------------------------------------------------------------------
main: 70860
main: <_MainProcess(MainProcess, started)>
dance: 70861
dance: <Process(myprocess1, started)>
dance的父进程编号: 70860
跳舞中...
sing: 70862
sing: <Process(Process-2, started)>
sing的父进程编号: 70860
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

2.3 参数使用

args参数使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

执行结果:

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

kwargs参数使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

执行结果:

任务执行中..
任务执行中..
任务执行中..
任务执行完成

2.4 守护进程

主进程退出子进程销毁不再执行，无需主进程等待子线程结束再结束
- 设置守护主进程方式： 子进程对象.daemon = True
- 销毁子进程方式： 子进程对象.terminate()

3. 线程概念

线程是cpu调度基本单位，每个进程至少有一个线程，这个线程是我们通常说的主线程，程序默认启动一个主线程，程序员自己创建的线程可以成为子线程，多线程可以完成多任务。

作用：

多线程完成多任务

3.1线程类Thread参数说明

Thread([group [, target [, name [, args [, kwargs]]]]])
- group: 线程组，目前只能使用None
- target: 执行的目标任务名
- args: 以元组的方式给执行任务传参
- kwargs: 以字典方式给执行任务传参
- name: 线程名，一般不用设置

使用start方法启动

import threading
import time

# 唱歌任务
def sing():
    # 扩展： 获取当前线程
    # print("sing当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在唱歌...%d" % i)
        time.sleep(1)

# 跳舞任务
def dance():
    # 扩展： 获取当前线程
    # print("dance当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在跳舞...%d" % i)
        time.sleep(1)


if __name__ == '__main__':
    # 扩展： 获取当前线程
    # print("当前执行的线程为：", threading.current_thread())
    # 创建唱歌的线程
    # target： 线程执行的函数名
    sing_thread = threading.Thread(target=sing)

    # 创建跳舞的线程
    dance_thread = threading.Thread(target=dance)

    # 开启线程
    sing_thread.start()
    dance_thread.start()

执行结果:

正在唱歌...0
正在跳舞...0
正在唱歌...1
正在跳舞...1
正在唱歌...2
正在跳舞...2

3.2 小结

导入线程模块
- import threading
创建子线程并指定执行的任务
- sub_thread = threading.Thread(target=任务名)
启动线程执行任务
- sub_thread.start()

3.3 线程注意点

线程、进程之间执行是无序的，由cpu调度决定
主线程会等待所有的子线程执行结束再结束
线程之间共享全局变量
线程之间共享全局变量数据出现错误问题
- 在g_num=0时，first_thread取得g_num=0。此时系统把first_thread调度为”sleeping”状态，把second_thread转换为”running”状态，t2也获得g_num=0
- 然后second_thread对得到的值进行加1并赋给g_num，使得g_num=1
- 然后系统又把second_thread调度为”sleeping”，把first_thread转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
- 这样导致虽然first_thread和first_thread都对g_num加1，但结果仍然是g_num=1
  - 解决办法
    - 线程同步[1. 线程等待、互斥锁]: 保证同一时刻只能有一个线程去操作全局变量同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说, 好比现实生活中的对讲机
      - 互斥锁：多个线程去抢锁，抢到先执行，没抢到锁需等待。保证共享数据不会出现问题
        优点
        保证关键代码只能一个线程从头到尾完整执行
        
        缺点：
        影响代码执行效率，多任务改成单任务
        容易出现死锁现象（一直等待对方释放锁）例子：男女双方一直等待对方先道歉，会造成程序停止响应，不在处理其他任务
  - 小结：
    - 线程执行无序
    - 主线程默认等待所有子线程执行结束再结束，设置守护主线程目的：主线程退出，子线程销毁
    - 需要在合适地方释放锁

3.进程和线程对比

关系对比
- 线程依附在进程里面
- 一个进程提供一条线程，进程可以创建多个线程
  
  [外链图片转存失败(img-UtlruBLQ-1565234302674)(C:\Users\54190\AppData\Roaming\Typora\typora-user-images\1565230545966.png)]
区别对比
- 进程之间不共享全局变量
- 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
- 创建进程的资源开销要比创建线程的资源开销要大
- 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
- 线程不能够独立执行，必须依存在进程中
- 多进程开发比单进程多线程开发稳定性要强
优缺点对比
- 进程优缺点:
  - 优点：可以用多核
  - 缺点：资源开销大
- 线程优缺点:
  - 优点：资源开销小
  - 缺点：不能使用多核