【python】-详解进程与线程

进程

1、多任务

（1）概念：同一时间执行多个任务，打开QQ的同时也可以打开微信

（2）作用：充分利用CPU资源，提高程序的执行效率

（3）表现形式：

• 并发：在一段时间内交替去执行多个任务（对于单核CPU处理）
• 并行：在一段时间内真正的同时一起执行多个任务（对于多核CPU）

2、进程介绍

（1）概念：进程是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位。也即
一个正在运行的程序就是一个进程

3、多进程

1 进程的创建步骤

• 导入进程包

  ​ import multiprocessing

• 通过进程类创建进程对象

  ​ 进程对象=multiprocessing.Process()

• 启动进程执行任务

  ​ 进程对象.start()

2 通过进程类创建进程对象

进程对象=multiprocessing.Process(target=任务名)
1

3 进程的创建与启动代码

###单任务
import time
'''
以下这种形式就是先唱完歌才能接着跳舞
共执行的时间是：3s
'''

#唱歌
def sing():
    for i in range (3):
        print("唱歌。。。。")
        time.sleep(0.5)

#跳舞
def dance():
    for i in range(3):
        print("跳舞。。。。")
        time.sleep(0.5)

if __name__ == '__main__':
    time_start=time.time()
    sing()
    dance()
    time_end=time.time()
    print("共耗费：",time_end-time_start)

'''
唱歌。。。。
唱歌。。。。
跳舞。。。。
跳舞。。。。
跳舞。。。。
共耗费： 3.0499579906463623
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#多任务多进程
import time
#1、导入进程包
import multiprocessing
'''
1、导入进程包
2、使用进程类创建进程对象
3、使用进程对象启动进程执行任务

'''
#唱歌
def sing():
    for i in range (3):
        print("唱歌。。。。")
        time.sleep(0.5)

#跳舞
def dance():
    for i in range(3):
        print("跳舞。。。。")
        time.sleep(0.5)



if __name__ == '__main__':
    time_start = time.time()

    #2、使用进程类创建进程对象
    sing_process=multiprocessing.Process(target=sing)
    dance_process=multiprocessing.Process(target=dance)
    #3、使用进程对象启动进程执行任务
    sing_process.start()
    dance_process.start()

    time_end = time.time()
    print("共耗费：", time_end - time_start)
'''
唱歌跳舞同时进行
共耗费： 0.016045808792114258
唱歌。。。。
跳舞。。。。
跳舞。。。。
唱歌。。。。
唱歌。。。。
跳舞。。。。
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

4、进程执行带有参数的任务

1 进程执行带有参数的任务

2 args 参数的使用

• 多参数的时候，需要按照顺序

3 kwargs 参数的使用

• 字典的键要与传的参数一致
• 不需要按照顺序执行

4 代码实现

import time
#1、导入进程包
import multiprocessing
'''
1、导入进程包
2、使用进程类创建进程对象
3、使用进程对象启动进程执行任务

'''
#唱歌
def sing(num,name):
    for i in range (num):
        print("{} :唱歌。。。。{}".format(name,i))
        time.sleep(0.5)
#跳舞
def dance(num,name):
    for i in range(num):
        print("{}:跳舞。。。。{}".format(name,i))
        time.sleep(0.5)
if __name__ == '__main__':
    time_start = time.time()
    #2、使用进程类创建进程对象
    sing_process=multiprocessing.Process(target=sing,args=(3,"蔡徐坤"))
    dance_process=multiprocessing.Process(target=dance,kwargs={'name':"吴亦凡",'num':3})
    #3、使用进程对象启动进程执行任务
    sing_process.start()
    dance_process.start()
    time_end = time.time()
    print("共耗费：", time_end - time_start)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

5 获取进程编号

作用：当进程的数量越来越多，如果没有办法区分主进程和子进程，无法进行有效的进程管理。

获取进程的编号：

• 获取当前进程编号

  ​ os.getpid()

• 获取当前父进程编号

  ​ os.getppid()

1 os.getpid()的使用

2 os.getppid()的使用

3 代码实现

def sing(num,name):
    print("唱歌进程的pid:",os.getpid())
    print("唱歌进程的父进程pid:", os.getppid())
def dance(num,name):
    print("跳舞进程的pid:", os.getpid())
    print("跳舞进程的父进程:", os.getppid())
if __name__ == '__main__':
    print("主进程的pid:",os.getpid())
'''
主进程的pid: 52044
唱歌进程的父进程pid: 52044
跳舞进程的父进程pid: 52044
'''
1
2
3
4
5
6
7
8
9
10
11
12
13

4 注意点

• 主进程会等待所有的子进程执行结束后再使用

• 设置守护主进程：主进程退出后直接销毁，不再执行子进程中的代码

  • work_process.daemon=True

def work():
    for i in range(10):
        print("工作中....")
        time.sleep(0.2)

if __name__ == '__main__':
    work_press=multiprocessing.Process(target=work)
    work_press.daemon=True
    work_press.start()
    time.sleep(2)
    print("主进程工作中...")
'''
工作中....
工作中....
工作中....
工作中....
工作中....
主进程工作中...
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

线程

1 线程的介绍

进程是分配资源的最小单位，一旦创建一个进程就会分配一定的资源，就像两人聊QQ需要打开两个QQ软件一样，一样浪费资源。

线程是程序执行的最小的单位。进程是只负责分配资源，而利用资源执行程序的是线程。进程是线程的容器，一个进程中最少有一个线程来负者执行程序。线程不需要中间拥有系统资源，只需要一点在运行中必不可少的资源，同一个进程的其他线程共享所拥有的全部资源。好比QQ软件（进程）打开两个窗口（两个线程）跟两个人聊天。

从上面两张图片可以看出，进程看成两个人干两件事（打开QQ、微信），线程是一个人干两件事（分别找两个人聊天）。

2 多线程完成多任务

1 线程的创建步骤

• 导入线程模块

  ​- import threading

• 通过线程类创建线程对象

  ​- 线程对象=threading.Thread(target=任务名)

  ​

• 启动线程执行任务

  ​ 线程对象.start()

  ​

2 线程的创建与启动的代码

if __name__ == '__main__':
    sing_thread=threading.Thread(target=sing)
    dance_thread=threading.Thread(target=dance)
    sing_thread.start()
    dance_thread.start()
1
2
3
4
5

3 线程执行带有参数的任务

与进程的创建方法一样，就不写了

4 主线程与子线程的结束顺序

• 设置守护主线程方式1:

  work_press=threading.Thread(target=work,daemon=True)
  1

• 方式2：

  work_press.setDaemon(True)
  1

5 线程 间的执行顺序

1 线程之间的执行顺序是 无序的 ，是由CPU随机调度的

2 获取当前的线程信息

6 进程和线程的对比

1 关系对比

• 线程是依附在进程里面的，没有进程就没有线程
• 一个进程默认提供一条线程，进程可以创建多个线程

2 区别对比

• 创建进程的开销要比创建线程的开销大
• 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
• 线程不是孤立执行，必须依存在进程之中