#并发和并行

#实现多任务的方式：

1.多进程模式

2.多线程模式

3.协程

进程>线程 >协程

#在linux下可以使用fork函数创建进程，

#在windows下可以引用multiprocessing模块，创建进程。

可以使用multiprocessing模块中的Process类创建新的进程

Process类说明

构造方法 __init__()

参数：

name: 进程名称

args: 任意位置参数

kwargs: 任意关键字参数

target: 进程实例所调用的对象

#创建父子进程执行不同的内容是多任务中固定的方法

#进程创建

from multiprocessing import Process

import time

import os

def task1():

while True:

time.sleep(1)

#os.getpid() 得到当前进程的id, pid: process id

#os.getppid() 得到当前进程的父进程id , ppid: parent process id

print("task111111111111", os.getpid(),"--------",os.getppid())

def task2():

while True:

time.sleep(1)

print("task222222222", os.getpid(),"--------",os.getppid())

if __name__=="__main__":

#给进程起的名字叫做 “任务1”

p = Process(target=task1, name="任务1")

p.start()

print(p.name) #打印进程的名字

#给进程起的名字叫做 “任务2”

p1 = Process(target=task2, name="任务2")

p1.start()

print(p1.name)

任务1

任务2

task111111111111 20165 -------- 16191

task222222222 20166 -------- 16191

task111111111111 20165 -------- 16191

task222222222 20166 -------- 16191

task111111111111 20165 -------- 16191

task222222222 20166 -------- 16191

Process 任务2:

Process 任务1:

Traceback (most recent call last):

Traceback (most recent call last):

time.sleep(1)

KeyboardInterrupt

KeyboardInterrupt

#进程创建

#可以传入多个参数，然后用多个参数来接收

def task1(s, v):

while True:

print(s, type(s))

time.sleep(s)

print("task111111111111", v,"---", os.getpid(),"--------",os.getppid())

def task2(s, v):

while True:

print(s, type(s))

time.sleep(s)

print("task222222222", v,"---", os.getpid(),"--------",os.getppid())

if __name__=="__main__":

#可迭代的参数args, args=(参数1，参数2)， 以元组的形式传入参数

p = Process(target=task1, name="任务1", args=(1,"aa"))

p.start()

print(p.name) #打印进程的名字

p1 = Process(target=task2, name="任务2", args=(2,"bb"))

p1.start()

print(p1.name)

任务1

1

任务2

2

task111111111111 aa --- 20873 -------- 16191

1

task222222222 bb --- 20876 -------- 16191

2

task111111111111 aa --- 20873 -------- 16191

1

task111111111111 aa --- 20873 -------- 16191

1

task222222222 bb --- 20876 -------- 16191

2

task111111111111 aa --- 20873 -------- 16191

1

Process 任务1:

Process 任务2:

Traceback (most recent call last):

KeyboardInterrupt

进程 > 线程 > 协程

from multiprocessing import Process

Process(target=函数， name=进程的名字， args=(给函数传递的参数))

#可以传入多个参数，然后用多个参数来接收

#全局变量m

m =1

def task1(s, v):

global m

while True:

print(s, type(s))

time.sleep(s)

m += 1

print("task111111111111","---", m)

def task2(s, v):

global m

while True:

print(s, type(s))

time.sleep(s)

m += 1

print("task222222222","---", m)

if __name__=="__main__":

#print("------os.getpid()")

#print(os.getpid())

#子进程

p = Process(target=task1, name="任务1", args=(1,"aa"))

p.start()

p1 = Process(target=task2, name="任务2", args=(2,"bb"))

p1.start()

num = 0

while True:

m += 1

print("------------->main", m)

num += 1

time.sleep(0.2)

#到10，进程就terminate(), 终止了

if num == 100:

p.terminate()

p1.terminate()

break

else:

print("--------->number ",num)

1

2

------------->main 2

--------->number 1

------------->main 3

--------->number 2

------------->main 4

--------->number 3

------------->main 5

task111111111111 --- 2

--------->number 4

------------->main 6

1

--------->number 5

------------->main 7

--------->number 6

------------->main 8

--------->number 7

------------->main 9

--------->number 8

------------->main 10

Process 任务2:

Traceback (most recent call last):

--------->number 9

------------->main 11

Process 任务1:

---------------------------------------------------------------------------

KeyboardInterrupt Traceback (most recent call last)

in ()

35 print("------------->main", m)

36 num += 1

---> 37 time.sleep(0.2)

38 #到10，进程就terminate(), 终止了

39 if num == 100:

KeyboardInterrupt:

Traceback (most recent call last):

KeyboardInterrupt

KeyboardInterrupt

#进程创建的方法

p = Process(target=task1, name="任务1", args=(1,"aa"))

p.start() #进程开始， 并执行任务

p.terminate() #进程结束

#多进程对于全局变量访问，在每一个全局变量里面都放一个m变量

# 保证每个进程访问变量互不干扰

# 这个和 可变，不可变对象没有关系，

#每个进程都独立的拥有一个全局变量的拷贝

m = 1 #不可变类型

list1 = [] #可变类型

def task1(s, name):

global m

while True:

print(s, type(s))

time.sleep(s)

m += 1

list1.append(str(m)+"task1")

print("task111111111111","---", m, list1)

def task2(s, name):

global m

while True:

print(s, type(s))

time.sleep(s)

m -= 1

list1.append(str(m)+"task1")

print("task222222222","---", m, list1)

if __name__ == "__main__":

print("os.getpid():",os.getpid())

#子进程

#根据打印的m的数值可以看出，每个进程都独立的拥有一个全局变量的拷贝

p = Process(target=task1, name="任务1", args=(1, "任务1"))

p.start()

print("p.name", p.name)

p1 = Process(target=task2, name="任务2", args=(1,"任务2"))

p1.start()

print("p1.name", p1.name)

os.getpid(): 16191

p.name 任务1

p1.name 任务2

1

1

task111111111111 --- 2 ['2task1']

task222222222 --- 0 ['0task1']

1

1

task111111111111 --- 3 ['2task1', '3task1']

task222222222 --- -1 ['0task1', '-1task1']

1

1

task111111111111 --- 4 ['2task1', '3task1', '4task1']

1

task222222222 --- -2 ['0task1', '-1task1', '-2task1']

1

Process 任务1:

Process 任务2:

Traceback (most recent call last):

Traceback (most recent call last):

KeyboardInterrupt

# 进程：自定义

from multiprocessing import Process

#继承于 Process 类

class MyProcess(Process):

def __init__(self, name):

#调用父类的构造函数

super(MyProcess, self).__init__()

#这里的name是用户自定义的时候传递的name参数

self.name = name

#重写run方法

def run(self):

n = 1

while True:

print("进程名字："+self.name)

print("{}---->自定义进程, n:{}".format(n,self.name))

n += 1

if __name__ == "__main__":

p = MyProcess("小明")

#p.start()所做的两件事情：1.开启新的进程 2.调用run()方法

p.start()

p1 = MyProcess("小红")

p1.start()

#p 和 p1这两个进程争夺cpu,cpu有其自己的调度方法， 执行顺序是不确定的，

#谁可以 获得时间片， 就执行谁

进程名字：小红

1---->自定义进程, n:小明

1---->自定义进程, n:小红

进程名字：小明

2---->自定义进程, n:小明

进程名字：小红

2---->自定义进程, n:小红

进程名字：小明

进程名字：小红

3---->自定义进程, n:小明

3---->自定义进程, n:小红

进程名字：小明

进程名字：小红

4---->自定义进程, n:小明

4---->自定义进程, n:小红

进程名字：小明

进程名字：小红

5---->自定义进程, n:小明

5---->自定义进程, n:小红

进程名字：小红

进程名字：小明

6---->自定义进程, n:小明

6---->自定义进程, n:小红

进程名字：小明

进程名字：小红

7---->自定义进程, n:小红

7---->自定义进程, n:小明

进程名字：小红

进程名字：小明

8---->自定义进程, n:小明

8---->自定义进程, n:小红

进程名字：小红

9---->自定义进程, n:小红

进程名字：小明

9---->自定义进程, n:小明

进程名字：小红

10---->自定义进程, n:小红

进程名字：小明

10---->自定义进程, n:小明

进程名字：小红

进程名字：小明

11---->自定义进程, n:小红

11---->自定义进程, n:小明

进程名字：小红

进程名字：小明

12---->自定义进程, n:小红

12---->自定义进程, n:小明

进程名字：小红

13---->自定义进程, n:小红

进程名字：小明

13---->自定义进程, n:小明

进程名字：小红

14---->自定义进程, n:小红

进程名字：小明

14---->自定义进程, n:小明

进程名字：小红

进程名字：小明

15---->自定义进程, n:小红

15---->自定义进程, n:小明

进程名字：小红

16---->自定义进程, n:小红

进程名字：小明

16---->自定义进程, n:小明

进程名字：小红

17---->自定义进程, n:小红

进程名字：小明

进程名字：小红

17---->自定义进程, n:小明

18---->自定义进程, n:小红

进程名字：小明

进程名字：小红

18---->自定义进程, n:小明

进程名字：小明

19---->自定义进程, n:小红

进程名字：小红

19---->自定义进程, n:小明

进程名字：小明

20---->自定义进程, n:小红

进程名字：小红

20---->自定义进程, n:小明

21---->自定义进程, n:小红

进程名字：小明

进程名字：小红

21---->自定义进程, n:小明

进程名字：小明

22---->自定义进程, n:小红

22---->自定义进程, n:小明

进程名字：小红

进程名字：小明

23---->自定义进程, n:小红

23---->自定义进程, n:小明

进程名字：小红

进程名字：小明

24---->自定义进程, n:小红

进程名字：小红

24---->自定义进程, n:小明

进程名字：小明

25---->自定义进程, n:小红

25---->自定义进程, n:小明

进程名字：小明

进程名字：小红

26---->自定义进程, n:小红

26---->自定义进程, n:小明

进程名字：小明

进程名字：小红

27---->自定义进程, n:小明

27---->自定义进程, n:小红

进程名字：小明

进程名字：小红

28---->自定义进程, n:小红

28---->自定义进程, n:小明

进程名字：小明

进程名字：小红

29---->自定义进程, n:小红

29---->自定义进程, n:小明

进程名字：小明

进程名字：小红

30---->自定义进程, n:小红

30---->自定义进程, n:小明

进程名字：小明

进程名字：小红

31---->自定义进程, n:小明

31---->自定义进程, n:小红

进程名字：小明

进程名字：小红

32---->自定义进程, n:小明

进程名字：小明

32---->自定义进程, n:小红

进程名字：小红

33---->自定义进程, n:小明

进程名字：小明

33---->自定义进程, n:小红

进程名字：小红

34---->自定义进程, n:小明

进程名字：小明

34---->自定义进程, n:小红

进程名字：小红

35---->自定义进程, n:小明

进程名字：小明

35---->自定义进程, n:小红

进程名字：小红

36---->自定义进程, n:小明

进程名字：小明

36---->自定义进程, n:小红

进程名字：小红

37---->自定义进程, n:小明

37---->自定义进程, n:小红

进程名字：小明

进程名字：小红

38---->自定义进程, n:小明

进程名字：小明

38---->自定义进程, n:小红

39---->自定义进程, n:小明

进程名字：小红

39---->自定义进程, n:小红

进程名字：小明

40---->自定义进程, n:小明

进程名字：小红

进程名字：小明

40---->自定义进程, n:小红

进程名字：小红

41---->自定义进程, n:小明

进程名字：小明

41---->自定义进程, n:小红

42---->自定义进程, n:小明

进程名字：小红

42---->自定义进程, n:小红

进程名字：小明

43---->自定义进程, n:小明

进程名字：小红

进程名字：小明

43---->自定义进程, n:小红

进程名字：小红

44---->自定义进程, n:小明

进程名字：小明

44---->自定义进程, n:小红

进程名字：小红

45---->自定义进程, n:小明

进程名字：小明

45---->自定义进程, n:小红

进程名字：小红

46---->自定义进程, n:小明

46---->自定义进程, n:小红

进程名字：小明

进程名字：小红

47---->自定义进程, n:小明

47---->自定义进程, n:小红

进程名字：小明

进程名字：小红

48---->自定义进程, n:小明

进程名字：小明

48---->自定义进程, n:小红

进程名字：小红

49---->自定义进程, n:小明

进程名字：小明

49---->自定义进程, n:小红

进程名字：小红

50---->自定义进程, n:小明

50---->自定义进程, n:小红

进程名字：小明

51---->自定义进程, n:小明

进程名字：小红

进程名字：小明

51---->自定义进程, n:小红

52---->自定义进程, n:小明

进程名字：小红

52---->自定义进程, n:小红

进程名字：小明

进程名字：小红

53---->自定义进程, n:小明

53---->自定义进程, n:小红

进程名字：小明

54---->自定义进程, n:小明

进程名字：小红

进程名字：小明

54---->自定义进程, n:小红

55---->自定义进程, n:小明

进程名字：小明

进程名字：小红

56---->自定义进程, n:小明

55---->自定义进程, n:小红

进程名字：小明

进程名字：小红

57---->自定义进程, n:小明

56---->自定义进程, n:小红

进程名字：小明

进程名字：小红

58---->自定义进程, n:小明

进程名字：小明

57---->自定义进程, n:小红

进程名字：小红

59---->自定义进程, n:小明

进程名字：小明

60---->自定义进程, n:小明

58---->自定义进程, n:小红

进程名字：小明

进程名字：小红

61---->自定义进程, n:小明

59---->自定义进程, n:小红

进程名字：小明

进程名字：小红

60---->自定义进程, n:小红

62---->自定义进程, n:小明

进程名字：小明

进程名字：小红

63---->自定义进程, n:小明

61---->自定义进程, n:小红

进程名字：小红

进程名字：小明

62---->自定义进程, n:小红

64---->自定义进程, n:小明

进程名字：小明

进程名字：小红

63---->自定义进程, n:小红

65---->自定义进程, n:小明

进程名字：小明

进程名字：小红

64---->自定义进程, n:小红

66---->自定义进程, n:小明

进程名字：小红

进程名字：小明

65---->自定义进程, n:小红

进程名字：小红

67---->自定义进程, n:小明

进程名字：小明

66---->自定义进程, n:小红

进程名字：小红

68---->自定义进程, n:小明

67---->自定义进程, n:小红

进程名字：小明

进程名字：小红

69---->自定义进程, n:小明

68---->自定义进程, n:小红

进程名字：小明

70---->自定义进程, n:小明

进程名字：小红

69---->自定义进程, n:小红

进程名字：小明

71---->自定义进程, n:小明

进程名字：小红

70---->自定义进程, n:小红

进程名字：小明

72---->自定义进程, n:小明

进程名字：小红

进程名字：小明

71---->自定义进程, n:小红

73---->自定义进程, n:小明

进程名字：小红

72---->自定义进程, n:小红

进程名字：小明

74---->自定义进程, n:小明

进程名字：小红

进程名字：小明

73---->自定义进程, n:小红

进程名字：小红

75---->自定义进程, n:小明

74---->自定义进程, n:小红

进程名字：小明

进程名字：小红

76---->自定义进程, n:小明

进程名字：小明

75---->自定义进程, n:小红

进程名字：小红

77---->自定义进程, n:小明

进程名字：小明

76---->自定义进程, n:小红

进程名字：小红

78---->自定义进程, n:小明

进程名字：小明

77---->自定义进程, n:小红

79---->自定义进程, n:小明

进程名字：小红

78---->自定义进程, n:小红

进程名字：小明

进程名字：小红

80---->自定义进程, n:小明

79---->自定义进程, n:小红

进程名字：小明

进程名字：小红

81---->自定义进程, n:小明

进程名字：小明

80---->自定义进程, n:小红

进程名字：小红

81---->自定义进程, n:小红

82---->自定义进程, n:小明

进程名字：小红

进程名字：小明

82---->自定义进程, n:小红

83---->自定义进程, n:小明

进程名字：小红

83---->自定义进程, n:小红

进程名字：小明

84---->自定义进程, n:小明

进程名字：小红

进程名字：小明

84---->自定义进程, n:小红

进程名字：小红

85---->自定义进程, n:小明

85---->自定义进程, n:小红

进程名字：小明

86---->自定义进程, n:小明

进程名字：小红

86---->自定义进程, n:小红

进程名字：小明

87---->自定义进程, n:小明

进程名字：小红

87---->自定义进程, n:小红

进程名字：小明

88---->自定义进程, n:小明

进程名字：小红

88---->自定义进程, n:小红

进程名字：小明

进程名字：小红

89---->自定义进程, n:小明

89---->自定义进程, n:小红

进程名字：小明

90---->自定义进程, n:小明

进程名字：小红

进程名字：小明

90---->自定义进程, n:小红

91---->自定义进程, n:小明

进程名字：小红

91---->自定义进程, n:小红

进程名字：小明

进程名字：小红

92---->自定义进程, n:小明

92---->自定义进程, n:小红

进程名字：小红

进程名字：小明

93---->自定义进程, n:小明

93---->自定义进程, n:小红

进程名字：小明

进程名字：小红

94---->自定义进程, n:小红

94---->自定义进程, n:小明

进程名字：小红

进程名字：小明

95---->自定义进程, n:小明

95---->自定义进程, n:小红

进程名字：小明

96---->自定义进程, n:小明

进程名字：小红

96---->自定义进程, n:小红

进程名字：小明

97---->自定义进程, n:小明

进程名字：小红

97---->自定义进程, n:小红

进程名字：小明

进程名字：小红

98---->自定义进程, n:小明

98---->自定义进程, n:小红

进程名字：小明

进程名字：小红

99---->自定义进程, n:小明

进程名字：小明

99---->自定义进程, n:小红

100---->自定义进程, n:小明

进程名字：小红

100---->自定义进程, n:小红

进程名字：小明

进程名字：小红

101---->自定义进程, n:小明

101---->自定义进程, n:小红

进程名字：小明

进程名字：小红

102---->自定义进程, n:小明

102---->自定义进程, n:小红

进程名字：小明

进程名字：小红

103---->自定义进程, n:小明

103---->自定义进程, n:小红

进程名字：小红

进程名字：小明

104---->自定义进程, n:小红

104---->自定义进程, n:小明

进程名字：小红

进程名字：小明

105---->自定义进程, n:小明

105---->自定义进程, n:小红

进程名字：小明

进程名字：小红

106---->自定义进程, n:小明

106---->自定义进程, n:小红

进程名字：小红

进程名字：小明

107---->自定义进程, n:小红

107---->自定义进程, n:小明

进程名字：小红

进程名字：小明

108---->自定义进程, n:小明

108---->自定义进程, n:小红

进程名字：小明

进程名字：小红

109---->自定义进程, n:小红

109---->自定义进程, n:小明

进程名字：小红

进程名字：小明

110---->自定义进程, n:小红

110---->自定义进程, n:小明

进程名字：小红

进程名字：小明

111---->自定义进程, n:小红

111---->自定义进程, n:小明

进程名字：小明

进程名字：小红

112---->自定义进程, n:小明

112---->自定义进程, n:小红

进程名字：小红

进程名字：小明

113---->自定义进程, n:小明

113---->自定义进程, n:小红

进程名字：小明

进程名字：小红

114---->自定义进程, n:小红

114---->自定义进程, n:小明

进程名字：小红

进程名字：小明

115---->自定义进程, n:小红

115---->自定义进程, n:小明

进程名字：小红

进程名字：小明

116---->自定义进程, n:小红

116---->自定义进程, n:小明

进程名字：小明

进程名字：小红

117---->自定义进程, n:小红

117---->自定义进程, n:小明

进程名字：小明

进程名字：小红

118---->自定义进程, n:小红

118---->自定义进程, n:小明

进程名字：小明

进程名字：小红

119---->自定义进程, n:小明

119---->自定义进程, n:小红

进程名字：小红

进程名字：小明

120---->自定义进程, n:小明

120---->自定义进程, n:小红

进程名字：小明

进程名字：小红

121---->自定义进程, n:小红

121---->自定义进程, n:小明

进程名字：小明

进程名字：小红

122---->自定义进程, n:小明

122---->自定义进程, n:小红

进程名字：小红

进程名字：小明

123---->自定义进程, n:小明

123---->自定义进程, n:小红

进程名字：小明

进程名字：小红

124---->自定义进程, n:小红

124---->自定义进程, n:小明

进程名字：小红

进程名字：小明

125---->自定义进程, n:小明

125---->自定义进程, n:小红

进程名字：小明

进程名字：小红

126---->自定义进程, n:小明

126---->自定义进程, n:小红

进程名字：小红

进程名字：小明

127---->自定义进程, n:小明

127---->自定义进程, n:小红

进程名字：小红

进程名字：小明

128---->自定义进程, n:小明

128---->自定义进程, n:小红

进程名字：小明

进程名字：小红

129---->自定义进程, n:小明

129---->自定义进程, n:小红

进程名字：小红

进程名字：小明

130---->自定义进程, n:小红

130---->自定义进程, n:小明

进程名字：小红

进程名字：小明

131---->自定义进程, n:小明

131---->自定义进程, n:小红

进程名字：小红

进程名字：小明

132---->自定义进程, n:小红

132---->自定义进程, n:小明

进程名字：小明

进程名字：小红

133---->自定义进程, n:小明

133---->自定义进程, n:小红

进程名字：小明

进程名字：小红

134---->自定义进程, n:小红

134---->自定义进程, n:小明

进程名字：小明

进程名字：小红

135---->自定义进程, n:小明

135---->自定义进程, n:小红

进程名字：小明

进程名字：小红

136---->自定义进程, n:小明

136---->自定义进程, n:小红

进程名字：小明

进程名字：小红

137---->自定义进程, n:小红

137---->自定义进程, n:小明

进程名字：小明

进程名字：小红

138---->自定义进程, n:小明

138---->自定义进程, n:小红

进程名字：小红

139---->自定义进程, n:小红

进程名字：小明

139---->自定义进程, n:小明

进程名字：小红

进程名字：小明

140---->自定义进程, n:小红

140---->自定义进程, n:小明

进程名字：小红

进程名字：小明

141---->自定义进程, n:小红

进程名字：小红

141---->自定义进程, n:小明

进程名字：小明

142---->自定义进程, n:小红

142---->自定义进程, n:小明

进程名字：小红

进程名字：小明

143---->自定义进程, n:小红

143---->自定义进程, n:小明

进程名字：小红

144---->自定义进程, n:小红

进程名字：小明

进程名字：小红

144---->自定义进程, n:小明

145---->自定义进程, n:小红

进程名字：小明

145---->自定义进程, n:小明

进程名字：小红

进程名字：小明

146---->自定义进程, n:小红

146---->自定义进程, n:小明

进程名字：小红

147---->自定义进程, n:小红

进程名字：小明

147---->自定义进程, n:小明

进程名字：小红

进程名字：小明

148---->自定义进程, n:小明

148---->自定义进程, n:小红

进程名字：小红

进程名字：小明

149---->自定义进程, n:小红

149---->自定义进程, n:小明

进程名字：小明

进程名字：小红

150---->自定义进程, n:小红

150---->自定义进程, n:小明

进程名字：小明

进程名字：小红

151---->自定义进程, n:小红

151---->自定义进程, n:小明

进程名字：小红

进程名字：小明

152---->自定义进程, n:小红

152---->自定义进程, n:小明

进程名字：小红

进程名字：小明

153---->自定义进程, n:小红

153---->自定义进程, n:小明

进程名字：小红

进程名字：小明

154---->自定义进程, n:小红

154---->自定义进程, n:小明

进程名字：小明

进程名字：小红

155---->自定义进程, n:小红

155---->自定义进程, n:小明

进程名字：小明

进程名字：小红

156---->自定义进程, n:小明

156---->自定义进程, n:小红

进程名字：小明

进程名字：小红

157---->自定义进程, n:小明

157---->自定义进程, n:小红

进程名字：小明

进程名字：小红

158---->自定义进程, n:小明

158---->自定义进程, n:小红

进程名字：小明

159---->自定义进程, n:小明

进程名字：小红

159---->自定义进程, n:小红

进程名字：小明

160---->自定义进程, n:小明

进程名字：小红

进程名字：小明

160---->自定义进程, n:小红

进程名字：小红

161---->自定义进程, n:小明

进程名字：小明

161---->自定义进程, n:小红

162---->自定义进程, n:小明

进程名字：小红

进程名字：小明

162---->自定义进程, n:小红

163---->自定义进程, n:小明

进程名字：小明

进程名字：小红

164---->自定义进程, n:小明

163---->自定义进程, n:小红

进程名字：小明

进程名字：小红

165---->自定义进程, n:小明

进程名字：小明

164---->自定义进程, n:小红

166---->自定义进程, n:小明

进程名字：小红

165---->自定义进程, n:小红

进程名字：小明

进程名字：小红

167---->自定义进程, n:小明

166---->自定义进程, n:小红

进程名字：小明

168---->自定义进程, n:小明

进程名字：小红

167---->自定义进程, n:小红

进程名字：小明

169---->自定义进程, n:小明

进程名字：小红

168---->自定义进程, n:小红

进程名字：小明

进程名字：小红

170---->自定义进程, n:小明

169---->自定义进程, n:小红

进程名字：小明

进程名字：小红

171---->自定义进程, n:小明

进程名字：小明

170---->自定义进程, n:小红

进程名字：小红

172---->自定义进程, n:小明

171---->自定义进程, n:小红

进程名字：小明

进程名字：小红

172---->自定义进程, n:小红

173---->自定义进程, n:小明

进程名字：小明

进程名字：小红

174---->自定义进程, n:小明

173---->自定义进程, n:小红

进程名字：小红

进程名字：小明

175---->自定义进程, n:小明

174---->自定义进程, n:小红

进程名字：小明

进程名字：小红

175---->自定义进程, n:小红

176---->自定义进程, n:小明

进程名字：小明

进程名字：小红

177---->自定义进程, n:小明

176---->自定义进程, n:小红

进程名字：小明

进程名字：小红

177---->自定义进程, n:小红

178---->自定义进程, n:小明

进程名字：小红

进程名字：小明

179---->自定义进程, n:小明

178---->自定义进程, n:小红

进程名字：小红

进程名字：小明

180---->自定义进程, n:小明

179---->自定义进程, n:小红

进程名字：小明

181---->自定义进程, n:小明

进程名字：小红

180---->自定义进程, n:小红

进程名字：小明

进程名字：小红

182---->自定义进程, n:小明

进程名字：小明

181---->自定义进程, n:小红

进程名字：小红

183---->自定义进程, n:小明

182---->自定义进程, n:小红

进程名字：小明

184---->自定义进程, n:小明

进程名字：小红

进程名字：小明

183---->自定义进程, n:小红

185---->自定义进程, n:小明

进程名字：小红

进程名字：小明

184---->自定义进程, n:小红

186---->自定义进程, n:小明

进程名字：小红

185---->自定义进程, n:小红

进程名字：小明

进程名字：小红

187---->自定义进程, n:小明

186---->自定义进程, n:小红

进程名字：小明

进程名字：小红

188---->自定义进程, n:小明

187---->自定义进程, n:小红

进程名字：小明

进程名字：小红

189---->自定义进程, n:小明

188---->自定义进程, n:小红

进程名字：小明

进程名字：小红

189---->自定义进程, n:小红

190---->自定义进程, n:小明

进程名字：小红

进程名字：小明

190---->自定义进程, n:小红

191---->自定义进程, n:小明

进程名字：小明

进程名字：小红

192---->自定义进程, n:小明

191---->自定义进程, n:小红

进程名字：小明

进程名字：小红

192---->自定义进程, n:小红

193---->自定义进程, n:小明

进程名字：小明

进程名字：小红

194---->自定义进程, n:小明

193---->自定义进程, n:小红

进程名字：小明

进程名字：小红

194---->自定义进程, n:小红

195---->自定义进程, n:小明

进程名字：小红

进程名字：小明

196---->自定义进程, n:小明

195---->自定义进程, n:小红

进程名字：小明

197---->自定义进程, n:小明

进程名字：小红

196---->自定义进程, n:小红

进程名字：小明

198---->自定义进程, n:小明

进程名字：小红

197---->自定义进程, n:小红

进程名字：小明

进程名字：小红

199---->自定义进程, n:小明

进程名字：小明

198---->自定义进程, n:小红

进程名字：小红

200---->自定义进程, n:小明

进程名字：小明

199---->自定义进程, n:小红

201---->自定义进程, n:小明

进程名字：小红

200---->自定义进程, n:小红

进程名字：小明

进程名字：小红

202---->自定义进程, n:小明

201---->自定义进程, n:小红

进程名字：小明

进程名字：小红

203---->自定义进程, n:小明

202---->自定义进程, n:小红

进程名字：小明

204---->自定义进程, n:小明

进程名字：小红

203---->自定义进程, n:小红

进程名字：小明

进程名字：小红

205---->自定义进程, n:小明

204---->自定义进程, n:小红

进程名字：小明

206---->自定义进程, n:小明

进程名字：小红

205---->自定义进程, n:小红

进程名字：小明

207---->自定义进程, n:小明

进程名字：小红

206---->自定义进程, n:小红

进程名字：小明

进程名字：小红

208---->自定义进程, n:小明

207---->自定义进程, n:小红

进程名字：小明

Process 小红:

Process 小明:

Traceback (most recent call last):

KeyboardInterrupt

#如果子进程的数量不多的时候，可以使用multiprocessing中的Process来动态生成多个进程

# 如果需要成千上完的目标，就需要用multiprocessing模块的Pool方法

#

#初始化Pool时候，可以指定一个最大进程数，当有新的请求提交到

#Pool时候，如果Pool没有满，哪儿就会创建一个新的进程来执行该请求

#如果Pool已经满了，那么该请求就会等待，直到Pool中有进程结束，才会创建新的进程来执行

from multiprocessing import Pool

import time

from random import random

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

print("完成任务， 用时：",(end-start))

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机"]

for task1 in tasks:

pool.apply_async(task, args=(task1,))

pool.close() #添加任务结束

pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

print("over")

开始做任务 吃饭

开始做任务 送手机

开始做任务 睡觉

开始做任务 打游戏

开始做任务 看手机

完成任务， 用时： 1.4287302494049072

完成任务， 用时： 1.8290107250213623

完成任务， 用时： 1.8619880676269531

完成任务， 用时： 1.8805663585662842

完成任务， 用时： 2.00169038772583

over

random() #random.random()会得到0-1之间的一个小数

0.5553077792159044

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

print("完成任务， 用时：",(end-start))

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机"]

for task1 in tasks:

pool.apply_async(task, args=(task1,))

pool.close() #添加任务结束

#pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

print("over") #如果不加上面的pool.join(),那么会首先打印出over这句话，之后再执行各个task

over

开始做任务 看手机

开始做任务 打游戏

开始做任务 睡觉

开始做任务 送手机

开始做任务 吃饭

完成任务， 用时： 0.27217555046081543

完成任务， 用时： 0.3936333656311035

完成任务， 用时： 0.8289740085601807

完成任务， 用时： 0.9655370712280273

完成任务， 用时： 1.4926941394805908

import os

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

print("完成任务: {}， 用时{}， 进程id{}".format(task_name,(end-start), os.getpid()))

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机","散步"]

for task1 in tasks:

pool.apply_async(task, args=(task1,))

pool.close() #添加任务结束

pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

print("over")

开始做任务 睡觉

开始做任务 吃饭

开始做任务 打游戏

开始做任务 看手机

开始做任务 送手机

完成任务: 吃饭， 用时0.8535048961639404， 进程id16618

开始做任务 散步

完成任务: 散步， 用时0.16600275039672852， 进程id16618

完成任务: 睡觉， 用时1.4405558109283447， 进程id16619

完成任务: 送手机， 用时1.5230963230133057， 进程id16622

完成任务: 打游戏， 用时1.5314967632293701， 进程id16621

完成任务: 看手机， 用时1.7721624374389648， 进程id16620

over

#当pool中的进程执行完毕此次任务后，

#则队列中的任务再加入这个进程

#实现了进程复用

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

return "完成任务: {}， 用时{}， 进程id{}".format(task_name,(end-start), os.getpid())

container = []

def callback_func(n):

container.append(n)

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机","散步"]

for task1 in tasks:

pool.apply_async(task, args=(task1,), callback=callback_func)

pool.close() #添加任务结束

pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

# for c in container:

# print(c)

print("over")

开始做任务 打游戏

开始做任务 看手机

开始做任务 吃饭

开始做任务 睡觉

开始做任务 送手机

开始做任务 散步

over

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

return "完成任务: {}， 用时{}， 进程id{}".format(task_name,(end-start), os.getpid())

container = []

#这里的参数n，就是task所return的内容

def callback_func(n):

container.append(n)

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机","散步"]

#进程每执行完一个task,该task就会去执行回调函数

for task1 in tasks:

pool.apply_async(task, args=(task1,), callback=callback_func)

pool.close() #添加任务结束

#当pool中没有任务了， 那么pool中为空， 那么这堵墙就没有了， 就可以执行主进程下面的语句了

pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

#循环打印出container中的语句

#在pool.apply_async()语句中，使用了回调函数，使得执行task后的return内容

#返回到了 callback_func()函数中， 而callback_func()函数是使用的一个list来接受返回的内容

#现在等到所有的进程执行完毕，就可以打印出来了

for c in container:

print(c)

print("over")

开始做任务 睡觉

开始做任务 吃饭

开始做任务 打游戏

开始做任务 送手机

开始做任务 看手机

开始做任务 散步

完成任务: 吃饭， 用时0.16063594818115234， 进程id19475

完成任务: 送手机， 用时0.5520751476287842， 进程id19479

完成任务: 打游戏， 用时0.666292667388916， 进程id19478

完成任务: 睡觉， 用时0.6702499389648438， 进程id19476

完成任务: 散步， 用时1.2905476093292236， 进程id19475

完成任务: 看手机， 用时1.9815318584442139， 进程id19477

over

#pool()方法可以实现指定进程数， 同时进程可以复用

#非阻塞式： 全部添加到队列中，立刻返回，

#并没有等到其它的进程执行完毕，但是回调函数是等待任务完成之后再执行

#从上述的显示结果可以看出，"散步"这个task做完后，再去执行的回调函数

# callback = callback_func()函数

#阻塞式 pool.apply(),等pool里面的进程执行完毕后，再加载另一个task

def task(task_name):

print("开始做任务 ",task_name)

start = time.time()

#睡眠几秒钟

time.sleep(random()*2)

end = time.time()

print("完成任务: {}， 用时{}， 进程id{}".format(task_name,(end-start), os.getpid()))

if __name__ == "__main__":

pool = Pool(5)

tasks = ["吃饭","睡觉","看手机","打游戏","送手机","散步"]

for task1 in tasks:

#阻塞式 pool.apply(),等pool里面的进程执行完毕后，再加载另一个task

#效率低下， 没有体现进程的复用特点

pool.apply(task, args=(task1,))

pool.close() #添加任务结束,停止往pool里面加载

#当pool中没有任务了， 那么pool中为空， 那么这堵墙就没有了， 就可以执行主进程下面的语句了

#pool中的子进程没有结束前，主进程要等待，不能向下继续执行

pool.join() #堵住主进程，不执行下面的print语句，直到子进程结束，才会执行下面的主进程print语句

print("over")

开始做任务 吃饭

完成任务: 吃饭， 用时0.010351181030273438， 进程id22763

开始做任务 睡觉

完成任务: 睡觉， 用时0.816246509552002， 进程id22764

开始做任务 看手机

完成任务: 看手机， 用时0.6943869590759277， 进程id22765

开始做任务 打游戏

完成任务: 打游戏， 用时0.555044412612915， 进程id22766

开始做任务 送手机

完成任务: 送手机， 用时1.7695050239562988， 进程id22767

开始做任务 散步

完成任务: 散步， 用时0.650540828704834， 进程id22763

over

#阻塞式任务的特点

添加一个任务，则执行一个任务，如果一个任务不结束，那么另一个任务就进不来

#进程池

pool = Pool(max) 创建进程对象池

pool.apply() 阻塞的

pool.apply_async() 非阻塞的

pool.close() 停止添加进程、

pool.join() 让主进程让步，直到执行完子进程的任务， 再回来执行主进程

#进程间的通信

#队列 Queue

#导入队列Queue

from queue import Queue

q = Queue(3)

q.put('A')

q.put('B')

q.put("C")

print(q.qsize())

#如果queue满了则只能等待，除非有空地 则添加成功

#q.put('d')

3

#进程间的通信

#队列 Queue

#导入队列Queue

from queue import Queue

q = Queue(3)

q.put('A')

q.put('B')

q.put("C")

print(q.qsize())

#如果queue满了则只能等待，除非有空地 则添加成功

#q.full()判断队列q是否满， 如果满，则返回True,否则返回False

#q.empty()判断队列q是否为空， 如果为空，则返回True,否则返回False

if not q.full():

q.put("F", timeout=1)

else:

print("q.full() is True")

3

q.full() is True

#进程间的通信

#队列 Queue

#导入队列Queue

from queue import Queue

q = Queue(3)

q.put('A')

q.put('B')

q.put("C")

print(q.qsize())

#如果queue满了则只能等待，除非有空地 则添加成功

if not q.full():

q.put("F", timeout=1)

else:

print("q.full() is True")

print(q.get())

print(q.get())

print(q.get())

#q.get()可以设置一个关键字参数timeout,表示在设定的timeout时间内

#如果没有获取到数值，那么就报错

print(q.get(timeout=1))

3

q.full() is True

A

B

C

---------------------------------------------------------------------------

Empty Traceback (most recent call last)

in ()

22 print(q.get())

23 print(q.get())

---> 24 print(q.get(timeout=1))

~/anaconda3/lib/python3.6/queue.py in get(self, block, timeout)

170 remaining = endtime - time()

171 if remaining <= 0.0:

--> 172 raise Empty

173 self.not_empty.wait(remaining)

174 item = self._get()

Empty:

#进程间通信

from multiprocessing import Process

import time

from queue import Queue

def download(q):

images = ["girl.jpg","boy.jpg","man.jpg"]

for img in images:

print("正在下载：", img)

time.sleep(0.5)

q.put(img) #往队列q里面放东西

def getfile(q):

while True:

try:

#设置超时时间，当超过了超时时间， 就会报错，

#进入except 分支，执行break跳出while循环

file_name = q.get(timeout=1)

print("{}保存成功".format(file_name))

except Exception as e:

print(e)

break

if __name__ == "__main__":

q = Queue(5)

p1 = Process(target = download(q))

p2 = Process(target = getfile(q))

p1.start() #进程p1是向队列q中放数据， q.put()

p1.join()

p2.start() #进程p2是向队列q中取数据， q.get(timeout=1)

p2.join() #这两个进程共用同一个队列数据

正在下载： girl.jpg

正在下载： boy.jpg

正在下载： man.jpg

girl.jpg保存成功

boy.jpg保存成功

man.jpg保存成功