python apply_async死锁_Python_系统编程

多任务：同一个时间段中，执行多个函数/运行多个程序.

操作系统可以同时运行多个任务:

操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，感觉就像所有任务都在同时执行一样。(时间片轮转)

任务 执行算法：

时间片轮转

优先级调度

调度算法(什么样的情况下按照什么样的规则，让哪个任务执行)

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

进程

线程

协程

并发：看上去一齐执行(任务数>内核数)

并行：真正一齐执行(内核数>任务数)

程序：编写完毕的代码，在没有运行的时候(一个可执行的代码，可以理解称没有生命)

进程：正在运行的代码(除了包含代码外，还需要运行环境，占用的内存，键盘，显示器等，可以理解称具有生命)

进程

创建子进程

os.fork()创建新的进程，为子进程

import os

import time

ret = os.fork() # 返回二个特殊值， 其中一个等于0(子进程)，一个不固定的大于0的值(父进程，pid)。都是int类型。

if ret == 0:

while True:

print('1')

time.sleep(1)

else:

while True:

print('2')

time.sleep(1)

不一定父进程先执行，或子进程先执行，哪个进程先执行，是依靠操作系统调度算法。

Note: os.fork()，只在Unix/Linux/Mac上运行，windows不可以。

getpid、getppid

import os

ret = os.fork()

print(ret)

if ret > 0:

print('父进程 - %d'%os.getpid())

else:

print('子进程 - %d - %d'%(os.getpid(), os.getppid()))

"""

1535

父进程 - 1534

0

子进程 - 1535 - 1534

"""

os.getpid(): 子进程的pid的值

os.getppid(): 父进程的pid的值

父进程中fork的返回值，就是刚刚创建出来的子进程的pid

父子进程的先后顺序

主进程执行完结束后，子进程没有结束。照样主进程结束掉，而子进程一样执行完程序。

import os

import time

ret = os.fork()

if ret == 0:

print('子进程')

time.sleep(5)

print('子进程over')

else:

print('父进程')

time.sleep(3)

print('over')

执行结果：

父进程

子进程

over

linxingzhangdeMacBook-Air:python linxingzhang$ 子进程over

over

光标定位到当前位置

全局变量在多个进程中不共享

import os

import time

g_num = 100

ret = os.fork()

if ret == 0:

g_num += 1

print('process-c - %d'%g_num)

else:

time.sleep(3)

print('process-p - %d'%g_num)

执行结果：

process-c - 101

process-p - 100

在进程中，全局变量，局部变量，在各自进程的命名空间中，互不干预。

进程和进程之间，数据无法共享。

同一台电脑进程之间通信：管道，消息队列...

不同一台电脑进程之间通信：网络

多个fork

第一种：多个fork情况，并列fork。

import os

# 父进程

ret = os.fork()

if ret == 0:

# 子进程

print('1')

else:

# 父进程

print('2')

# 父子进程

ret = os.fork()

if ret == 0:

# 孙子进程

# 2儿子进程

print('11')

else:

# 儿子进程

# 父进程

print('22')

执行结果：

2

22

1

11

11

22

第二种fork情况，包含fork

import os

# 父进程

ret = os.fork()

if ret == 0:

# 子进程

print('1')

else:

# 父进程

print('2')

ret = os.fork()

if ret == 0:

# 2儿子进程

print('11')

else:

# 父进程

print('22')

执行结果：

2

22

1

11

父子进程的执行顺序：

父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法

Process创建子进程

multiprocessing模块是跨平台版本的多进程模块。

# coding=utf-8

from multiprocessing import Process

import time

def test():

while True:

print('--test')

time.sleep(2)

ret = Process(target=test)

ret.start() # 子进程执行代码

while True:

print('--mian')

time.sleep(1)

当前执行结果：

--mian

--test

--mian

--test

--mian

--mian

--test

--mian

--mian

... # 循环

# coding=utf-8

from multiprocessing import Process

import os

# 子进程执行的代码

def run_proc(name):

print('子进程运行中，name= %s ,pid=%d...' % (name, os.getpid()))

if __name__ == '__main__':

print('父进程 %d.' % os.getpid())

p = Process(target=run_proc, args=('test',))

print('子进程将要执行')

p.start() # 子进程开始

p.join() # 等待进程标记结束后才继续往下走 # 堵塞

print('子进程已结束')

执行结果

父进程 3045.

子进程将要执行

子进程运行中，name