首页 > > 网络编程 > 其它 >

02-多任务编程

2019-04-25 06:54:30来源：博客园阅读 ()

一、多任务

多任务是指在同一时间内执行多个任务，使用多任务就能充分利用CPU资源，提高程序的执行效率

执行方式：

并发：在一段时间内交替去执行任务；；单核cpu处理多任务,操作系统轮流让各个软件交替执行

并行：对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。

cup核心（八核）数大于任务数时——并行，反之，并发

二、进程：实现多任务的一种方式

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

作用：是操作系统进行资源分配的基本单位，每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据，给程序的运行（线程）提供了资源和环境

注意：

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

2.import multiprocessing #导入进程包

1.进程类说明

Process([group [, target [, name [, args [, kwargs]]]]])

group：指定进程组，目前只能使用None

target：执行的目标任务名--------执行的函数名

name：进程名字

args：以元组方式给执行任务传参；组方式传参一定要和参数的顺序保持一致

kwargs：以字典方式给执行任务传参；字典方式传参字典中的key一定要和参数名保持一致

2.Process创建的实例对象的常用方法:

start()：启动子进程实例（创建子进程）

join()：等待子进程执行结束；其他进程阻塞在此处，等待该进程执行结束在执行

terminate()：不管任务是否完成，立即终止子进程

3.Process创建的实例对象的常用属性:

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

4.下面的代码可以看出两个是同时运行的

 1 import multiprocessing
 2 import time
 3  
 4  
 5 # 跳舞任务
 6 def dance():
 7     for i in range(5):
 8         print("跳舞中...")
 9         time.sleep(1)
10  
11 # 唱歌任务
12 def sing():
13     for i in range(5):
14         print("唱歌中...")
15         time.sleep(1)
16  
17 if __name__ == '__main__':
18     # 创建跳舞的子进程
19     # group: 表示进程组，目前只能使用None
20     # target: 表示执行的目标任务名(函数名、方法名)
21     # name: 进程名称, 默认是Process-1, .....
22     dance_process = multiprocessing.Process(target=dance, name="myprocess1")
23     sing_process = multiprocessing.Process(target=sing)
24  
25     # 启动子进程执行对应的任务
26     dance_process.start()
27     sing_process.start()

3.进程编号：

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

os.getpid() 当前进程编号

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

4.注意：

1.进程之间不共享全局变量

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

2.进程之间执行也是无序的

它是由操作系统调度决定的，操作系统调度哪个进程，哪个进程就先执行，没有调度的进程不能执行。

为什么无序：因为程序执行之前要先用cpython解释器，不管有几核的cpu，它的全局解释器锁（GIL）每次只允许通过一个线程通过，所以Python是个假的多任务

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

若想让主进程和子进程同步结束，可以设置：守护主进程、子进程销毁

设置守护主进程方式：子进程对象.daemon = True

进程对象 = multiprocessing.Process(target=show_info, daemon=True)

销毁子进程方式：子进程对象.terminate()

Eg：

 1             
 2 import multiprocessing
 3 import time
 4  
 5 # 定义进程所需要执行的任务
 6 def task():
 7     for i in range(10):
 8         print("任务执行中...")
 9         time.sleep(0.2)
10  
11 if __name__ == '__main__':
12     # 创建子进程
13     sub_process = multiprocessing.Process(target=task)
14     # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
15     # sub_process.daemon = True
16     sub_process.start()
17  
18     time.sleep(0.5)
19     print("over")
20     # 让子进程销毁
21     sub_process.terminate()
22     exit()
23

三、线程：多线程可以完成多任务

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

线程是Python程序中实现多任务的另外一种方式，线程的执行需要cpu调度来完成。

2.线程模块：import threading

线程类：Thread([group [, target [, name [, args [, kwargs]]]]])

name: 线程名，一般不用设置；其他属性同进程类

线程传参：同进程

3.注意：

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

线程之间执行是无序的，它是由cpu调度决定的，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。

 1 import threading
 2 import time
 3  
 4 def task():
 5     time.sleep(1)
 6     print("当前线程:", threading.current_thread().name)
 7  
 8 if __name__ == '__main__':
 9     for _ in range(5):
10         sub_thread = threading.Thread(target=task)
11         sub_thread.start()

2.主线程会等待所有的子线程执行结束再结束

设置守护主线程（主线程退出子线程销毁）有两种方式：

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

线程对象.setDaemon(True)

线程没有terminate()函数

拓展：守护线程：

其工作方式是：守护线程一般是一个等待客户端请求服务的服务器，如果没有客户端请求，守护线程就闲置。如果把一个线程设置成守护线程，就表示这个线程是不重要的，程序退出时不需要等待这个线程执行完成

3.线程之间共享全局变量:数据共享

共享全局变量数据出现错误问题：

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

实现方式：

1.线程等待(join)：a.start() a.join() b.start()

2.互斥锁

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

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

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

使用步骤：

# 创建锁
mutex = threading.Lock()
 
# 上锁
mutex.acquire()
 
...
这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...
 
# 释放锁
mutex.release()

注意：

1.acquire和release方法之间的代码同一时刻只能有一个线程去操作

2.如果在调用acquire方法的时候其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。

Eg：

 1 import threading
 2  
 3  
 4 # 定义全局变量
 5 g_num = 0
 6  
 7 # 创建全局互斥锁
 8 lock = threading.Lock()
 9  
10 # 循环一次给全局变量加1
11 def sum_num1():
12     # 上锁
13     lock.acquire()
14     for i in range(1000000):
15         global g_num
16         g_num += 1
17  
18     print("sum1:", g_num)
19     # 释放锁
20     lock.release()
21  
22 # 循环一次给全局变量加1
23 def sum_num2():
24     # 上锁
25     lock.acquire()
26     for i in range(1000000):
27         global g_num
28         g_num += 1
29     print("sum2:", g_num)
30     # 释放锁
31     lock.release()
32  
33 if __name__ == '__main__':
34     # 创建两个线程
35     first_thread = threading.Thread(target=sum_num1)
36     second_thread = threading.Thread(target=sum_num2)
37     # 启动线程
38     first_thread.start()
39     second_thread.start()
40