刀刀的知识积累

多任务编程

更新时间: 2024-04-19 16:14:23

# 编辑器vim

vim是一款功能强大的文本编辑器，也是早年Vi编辑器的加强版，它最大的特色就是使用命令进行编辑，完全脱离了鼠标的操作。

工作模式：

  • 命令模式
  • 编辑模式
  • 末行模式

注意

vim打开文件进入的是命令模式，编辑模式和末行模式之间不能进行切换，都要通过命令模式来完成

安装命令： sudo apt-get install
卸载命令: sudo apt-get remove

# 多任务介绍

利用现学知识能够让两个函数或者方法同时执行吗？

不能，因为之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成另外一个函数或者方法才能执行，要想实现这种操作就需要使用多任务，
多任务的最大好处是充分利用CPU资源，提高程序的执行效率

  • 多任务的概念
    多任务是指在同一时间内执行多个任务，例如：现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。

# 多任务的执行方式

  • 并发
    在一段时间内交替去执行任务。

    例如

    对于单核cpu处理多任务，操作系统轮流让各个软件交替执行，假如：软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒，这样反复执行下去。表面上看，每个软件都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像这些软件都在同时执行一样，这里需要注意单核cpu是并发的执行多任务的

  • 并行
    对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。

# 进程

在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。

比如：显示生活中的公司可以理解成是一个进程，公司提供办公资源(电脑、办公桌椅等)，真正干活的是员工，员工可以理解成线程。

注意

一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。

# 进程的作用

单进程效果图：

多进程效果图：

# 多进程使用

  1. 导入进程包
# 导入进程包
import multiprocessing
1
2
  1. Process进程类的说明
    Process([group [,target [,name [,args [,kwargs]]]]])
  • group: 指定进程组，目前只能用None
  • target：执行的目标任务名
  • name: 进程名字
  • args: 以元组方式给执行任务传参
  • kwargs: 以字典方式给执行任务传参

Process创建的实例对象的常用方法：

  • start(): 启动子进程实例（创建子进程）
  • join(): 等待子进程执行结束
  • terminate(): 不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：
name: 当前进程的别名，默认为Process-N,N为从1开始递增的整数

  1. 代码实现

 



















 
 
 
 
 
 






import time
import multiprocessing

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

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

if __name__ == '__main__':
    # 单进程需要10秒钟完成
    # 最少有一个进程，这个进程中最少有一个线程
    # 多进程需要5秒完成

    # 注意！！
    # 三个进程： 1个主进程， 2个子进程
    # 三个线程： 每个进程里有一个线程

    # 创建子进程
    # Process:
    # target: 指定执行的任务名
    my_dance = multiprocessing.Process(target=dance)
    my_sing = multiprocessing.Process(target=sing)

    # 开启子进程(如果不开启，是不会执行子进程的)
    my_dance.start()
    my_sing.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
30
31
32

# 获取进程编号

获取进程编号的目的是验证主进程和子进程的关系，可以得知子进程是由哪个主进程创建出来的。
获取进程编号的两种操作：

  • 获取当前进程编号
    os.getpid() 表示获取当前进程编号

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

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

import time
import multiprocessing
import os

def dance(count,a):
    for i in range(count):
        time.sleep(1)
        print("跳舞", a)

if __name__ == '__main__':
    # 带参数的函数
    # ars: 元组！！！（单个元素的元组有逗号,)
    # kwargs: 字典!!!(key值要和函数中的形参完全重名)
    # my_dance = multiprocessing.Process(target=dance, args=(5,2))
    my_dance = multiprocessing.Process(target=dance, kwargs={"count":5, "a":'bbb'})

    # 开启子进程(如果不开启，是不会执行子进程的)
    my_dance.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 进程的注意点

# 进程之间不共享全局变量

import time
import multiprocessing

g_num = []

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

def my_read():
    global g_num
    print(g_num)

if __name__ == '__main__':
    my_write_process = multiprocessing.Process(target=my_write)
    my_read_process = multiprocessing.Process(target=my_read)

    my_write_process.start()
    # 保证数据写入完毕
    time.sleep(1)
    my_write_process.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

创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

# 守护主进程

import multiprocessing
import time


def func():
    for i in range(5):
        time.sleep(0.2)
        print("func")

if __name__ == '__main__':
    # 主进程会等待子进程结束之后再结束
    # 程序一旦运行 就会默认创建主进程
    my_func = multiprocessing.Process(target=func)  # 主进程创建了子进程
    my_func.start() # 主进程开启子进程

    print("主进程:over")
    exit()

   """
  主进程:over
  func
  func
  func
  func
  func
   """
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

主进程会等待所有的子进程执行结束再结束

  • 为了保证子进程能够正常的运行，主进程会等待所有的子进程执行完成以后再销毁，设置守护主进程的目的是主进程退出子进程销毁，不让主进程再等待子进程去执行。
  • 设置守护主进程方式：子进程对象.daemon = True
  • 销毁子进程方式：子进程对象.terminate()
# 让子进程随着主进程的结束而结束的两种方式
# 1. 守护进程
# 2. 手动设置
import multiprocessing
import time


def func():
    for i in range(5):
        time.sleep(0.2)
        print("func")

if __name__ == '__main__':
    # 主进程会等待子进程结束之后再结束
    # 程序一旦运行 就会默认创建主进程
    my_func = multiprocessing.Process(target=func)  # 主进程创建了子进程
    # 设置守护进程(注意：需要再start之前设置，否则无效)
    # my_func.daemon = True
    my_func.start() # 主进程开启子进程

    time.sleep(0.5)
    # 手动设置
    my_func.terminate()
    print("主进程:over")
    exit()
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

# 线程

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

# 线程的概念

现成是进程中执行代码的一个分支，每个执行分支（现成）要想工作执行代码需要cpu进行调度，也就是说现成是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。

# 线程的作用

多线程可以完成多任务

# 多线程的使用

  1. 导入线程模块
import threading
1
  1. 线程类Thread参数说明 Thread([group[, target[, name[, args[, kwargs]]]]])
  • group: 线程组，目前只能使用None
  • target: 执行的目标任务名
  • args: 以元组的方式给执行任务传参
  • kwargs: 以字典方式给执行任务传参
  • name: 线程名，一般不用设置
  1. 启动线程 启动线程使用start方法
import time
import threading

def sing(msg):
    while True:
        print(f"我在唱歌，{msg}...")
        time.sleep(1)

def dance(msg):
    while True:
        print(f"我在跳舞，{msg}...")
        time.sleep(1)

# 创建一个唱歌的线程
sing_thread = threading.Thread(target=sing, args=("哈哈哈",))

# 创建一个跳舞的线程
dance_thread = threading.Thread(target=dance, kwargs={"msg":"啦啦啦"})

# 让线程去干活吧
sing_thread.start()
dance_thread.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 线程的注意点

  1. 线程之间执行是无序的
import threading
import time

def func():
    time.sleep(1)
    print(threading.current_thread())

if __name__ == '__main__':
    for i in range(5):
        my_func = threading.Thread(target=func)
        my_func.start()

# <Thread(Thread-5 (func), started 415016)>
# <Thread(Thread-2 (func), started 415236)>
# <Thread(Thread-1 (func), started 406440)>
# <Thread(Thread-4 (func), started 413300)>
# <Thread(Thread-3 (func), started 406356)>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  1. 主线程会等待所有的子线程执行结束再结束
    守护主线程： 守护主线程就是主线程退出子线程销毁不再执行
    设置守护主线程有两种方式：
  • threading.Thread(target=show_info, daemon=True)
  • 线程对象.deamon = True
import threading
import time

def func():
    for i in range(5):
        time.sleep(0.2)
        print("func")

if __name__ == '__main__':
    my_func = threading.Thread(target=func, daemon=True)
    my_func.daemon = True
    my_func.start()

    time.sleep(0.5)
    print("over")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  1. 线程之间共享全局变量
import threading
import time

# 结论：由于线程是依附于进程的，一个进程中的所有的线程都是使用的同一片内存空间
# 一个进程中的线程是共享全局变量的
g_num = []

def my_write():
    global g_num

    for i in range(5):
        g_num.append(i)

def my_read():
    global g_num
    print(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()

# [0,1,2,3,4]
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
  1. 线程之间共享全局变量数据出现错误问题
import threading

g_num = 0

def sum_num1():
    global g_num
    for i in range(10000000):
        g_num += 1
    print("sum_num1",g_num)

def sum_num2():
    global g_num
    for i in range(10000000):
        g_num += 1
    print("sum_num2",g_num)

if __name__ == '__main__':
    sub_num1 = threading.Thread(target=sum_num1)
    sub_num2 = threading.Thread(target=sum_num2)
    sub_num1.start()
    sub_num2.start()

# sum_num1 19784747
# sum_num2 20000000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

全局变量数据错误的解决办法

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

  1. 线程等待(join)
import threading

g_num = 0

def sum_num1():
    global g_num
    for i in range(10000000):
        g_num += 1
    print("sum_num1",g_num)

def sum_num2():
    global g_num
    for i in range(10000000):
        g_num += 1
    print("sum_num2",g_num)

if __name__ == '__main__':
    sub_num1 = threading.Thread(target=sum_num1)
    sub_num2 = threading.Thread(target=sum_num2)
    sub_num1.start()
    # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
    # 线程同步： 一个任务执行完以后另外一个任务才能执行，同一个时刻只有一个任务在执行
    sub_num1.join()
    sub_num2.start()

# sum_num1 10000000
#   sum_num2 20000000
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
  1. 互斥锁

# 互斥锁

对共享数据进行锁定，保证同一时刻只能有一个线程去操作

注意

互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁

thraading模块中定义了Lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。

import threading

g_num = 0

# 1.创建锁
mutex = threading.Lock()

def sum_num1():
    global g_num
    # 2.上锁
    mutex.acquire()
    for i in range(10000000):
        g_num += 1
    # 3.解锁(如果不解锁就会产生死锁问题)
    mutex.release()
    print("sum_num1",g_num)

def sum_num2():
    global g_num
    # 2.上锁(同一把锁，必须先解锁才可以上锁)
    mutex.acquire()
    for i in range(10000000):
        g_num += 1
    # 3.解锁(如果不解锁就会产生死锁问题)
    mutex.release()
    print("sum_num2",g_num)

if __name__ == '__main__':
    sub_num1 = threading.Thread(target=sum_num1)
    sub_num2 = threading.Thread(target=sum_num2)
    sub_num1.start()
    sub_num2.start()

# sum_num1 10000000
#   sum_num2 20000000
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

← 网络编程 →

MIT Licensed | Copyright © 2021-present 刀刀