标签：rmi 结束 情况 解决 main tar contain 包括 queue
? 较为通俗的去理解并发这件事情本身，这就要牵扯到计算机的发展。我再这笼统的概括，在网上能够找到十分详细的计算机发展史。
? https://blog.csdn.net/zzwu/article/details/77792789——请参见大佬的文章
? 在计算及一开始，工业生产能力并不能实现如今的多核的生产条件，当然也包括 那个时候并没有相关的理论。所以，在那个时候运行计算机那是相当的麻烦，很多人只能排着队等着来。这时候，优秀的程序猿就思考着为什么不能在计算机计算他人的内容的时候，接着运行别人的呢。因此他们就想到了并发——同时运行多个程序在一个处理器上。因为当程序在运行的时候，除开一些较为复杂的计算下，处理器占用较为多之外，很多时候都是进行的文件的读写 也就是 I/O 功能，这只占用计算机处理器的一小部分，大多数的部分就只能白白浪费。毕竟，效率就是生产力啊!!
? 引用百度的正规称呼——“并发，在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。”——应用自百度
? 正在进行的一个过程或者说一个任务。
? 程序是一对代码，进程则是程序的运行过程。
? 并发是看起来是同时进行了，但实际是处理器在多个任务之间的高速来回移动。
? 并行是真正的同时运行，但条件是得有多个CPU。因为一个CPU只能执行一个任务。
?
? **创建进程**
?
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，可用来开启一个子进程
?
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
? **参数介绍**
group参数未使用，值始终为None
?
target表示调用对象，即子进程要执行的任务
?
args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)
?
kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}
?
name为子进程的名称
? **方法介绍**
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
?
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
?
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间。
? **属性介绍**
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
?
p.name:进程的名称
?
p.pid：进程的pid
? **windows的Process必须在 if name == ‘main‘:下**
?
? **创建方式一**
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
p2 = Process(target=people, args=("李四", "man",))
p3 = Process(target=people, args=("狗蛋", "female",))
?
p1.start()
p2.start()
p3.start()
?
print("主要程序")
? **方式二**
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
class People(Process):
def __init__(self, name, sex):
super().__init__()
self.name = name
self.sex = sex
?
def run(self):
print("%s is %s" % (self.name, self.sex))
?
?
if __name__ == ‘__main__‘:
p1 = People("张三", "man")
p2 = People("李四", "man")
p3 = People("狗蛋", "female")
?
p1.start()
p2.start()
p3.start()
?
print("主要程序")
? 通过上面的创建，能发现的一个问题就是：在主进程都已经结束完成后，子进程并没有完成。因为我们看到的代码只是向处理器发出了一个信号，但是实际上并没有运行。而主进程并不需要进行进程方面的创建，直接就运行了。
? 那么，主进程能够等着子进程运行完成之后，自己再进行吗？
? 答案显然是可以的。
? 只需要在主进程之前加上joint()就可以。
? joint就是认为的对主程序进行阻塞，只有joint所对应的子进程运行完成后，主进程才能运行。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
p2 = Process(target=people, args=("李四", "man",))
p3 = Process(target=people, args=("狗蛋", "female",))
?
p1.start()
p2.start()
p3.start()
?
p1.join()
p2.join()
p3.join()
?
print("主要程序")
#注意：有多少个对象，就要有对应的join
? **注意：加上joint的进程并不是串行**
? 因为joint阻塞了主进程，但是子进程还是并发的在进行着。和串行一个一个运行还是有着本质的不用的。
? **对象其他属性或方法**
? **terminal 与 is——alive**
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
p1.start()
p1.terminate()
print(p1.is_alive())
print("主要程序")
运行后的结果：
True
主要程序
? **name 与 pid**
?
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
p1.start()
?
print(p1.name, p1.pid)
?
print("主要程序")
运行结果：
Process-1 17072
主要程序
张三 is man
? 守护进程就是伴随主进程左右的子进程，在主进程结束之前，自己绝对不会结束的子进程。
? **强调：一、主进程结束就终止；二、守护进程内不能开子进程，否则抛出异常**
?
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
?
p1.daemon = True
p1.start()
?
print("主进程")
?
# daemon必须要在start上面
? 并发虽然解决了效率的问题，但是也带来了一个问题就是容易带来错乱。
from multiprocessing import Process
import os,time
def work():
print(‘%s is running‘ %os.getpid())
time.sleep(2)
print(‘%s is done‘ %os.getpid())
?
if __name__ == ‘__main__‘:
for i in range(3):
p=Process(target=work)
p.start()
运行结果：
第一次结果
19428 is running
19364 is running
18716 is running
19428 is done
18716 is done
19364 is done
?
?
第二次结果
28012 is running
7920 is running
23080 is running
7920 is done
28012 is done
23080 is done
? 互斥锁将解决这个问题。
? 互斥锁就是一个门卫，谁抢到谁先进去，剩下的人在下面等着。
? 虽然保证了质量，但是效率也就不存在了。互斥锁将本来的并发变成了串行。
from multiprocessing import Process,Lock
import os,time
def work(lock):
lock.acquire() #加锁
print(‘%s is running‘ %os.getpid())
time.sleep(2)
print(‘%s is done‘ %os.getpid())
lock.release() #释放锁
if __name__ == ‘__main__‘:
lock=Lock()
for i in range(3):
p=Process(target=work,args=(lock,))
p.start()
#加上锁acquire之后一定要在最后release 否则下面的数据根本进不去
? **互斥锁与joint**
? joint是一个一个的运行，即上一个结束，下一个进去
? 互斥锁是多个一起去抢，谁抢到谁运行。然后再抢，在运行。如此循环往复。
? 即，join是将一个任务整体串行，而互斥锁的好处则是可以将一个任务中的某一段代码串行，比如只让task函数中的get任务串行
def task(name,):
search(name) # 并发执行
?
lock.acquire()
get(name) #串行执行
lock.release()
? 互斥锁中可以有部分是并发执行，而joint无法做到
? **重要**
#队列的创建
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from multiprocessing import Process
import queue
?
?
def people(name, sex):
print("%s is %s" % (name, sex))
?
?
if __name__ == ‘__main__‘:
p1 = Process(target=people, args=("张三", "man",))
p2 = Process(target=people, args=("李四", "man",))
p3 = Process(target=people, args=("狗蛋", "female",))
?
q = queue.Queue(2)
q.put(p1)
q.put(p2)
print(q.full())
?
p1.start()
p2.start()
p3.start()
print(q.get())
print(q.get())
?
print(q.empty())
?
print("主要程序")
#如果q.put(）和 q.get()查过2 程序会卡住不再运行
本文知识点引自与http://www.cnblogs.com/linhaifeng/大佬
标签：rmi 结束 情况 解决 main tar contain 包括 queue
原文地址：https://www.cnblogs.com/takafter/p/9385924.html
