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.join只能join住start开启的进程，而不能join住run开启的进程

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

# -*- coding:utf-8 -*-
# /user/bin/python
import time
import random
from multiprocessing import Process
def eat(name):
    print("%s eating" % name)
    time.sleep(random.randint(1,3))
    print("%s eat end" % name)
if __name__ == ‘__main__‘:

    p1 = Process(target=eat, args=("alex",))
    p2 = Process(target=eat, args=("nickle",))
    p3 = Process(target=eat, args=("json",))
    p4 = Process(target=eat, args=("tom",))

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print("主线程")

"""
输出结果：
主线程
alex eating
nickle eating
json eating
tom eating
nickle eat end
json eat end
alex eat end
tom eat end
"""

# -*- coding:utf-8 -*-
# /user/bin/python
import time
import random
from multiprocessing import Process
class eat(Process):

    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print("%s eating" % self.name)
        time.sleep(random.randint(1,3))
        print("%s eat end" % self.name)
if __name__ == ‘__main__‘:
    p1 = eat("alex")
    p2 = eat("nickle")
    p3 = eat("json")
    p4 = eat("tom")

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print("主进程")

"""
输出结果：
主进程
alex eating
json eating
nickle eating
tom eating
nickle eat end
tom eat end
json eat end
alex eat end
"""

# -*- coding:utf-8 -*-
# /user/bin/python
from multiprocessing import Process
import time
import random
class eat(Process):

    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print("%s eating" % self.name)
        time.sleep(random.randint(1,3))
        print("%s eat end" % self.name)
if __name__ == ‘__main__‘:
    p = eat("nickle")
    p.start()

    p.terminate() # 关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
    print(p.is_alive()) # 结果为True
    time.sleep(random.randint(1,3))
    print("go")
    print(p.is_alive())  # 结果为False

"""
输出结果：
True
go
False
"""

# -*- coding:utf-8 -*-
# /user/bin/python
from multiprocessing import Process
import time
import random
class eat(Process):

    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print("%s eating" % self.name)
        time.sleep(random.randint(1,3))
        print("%s eat end" % self.name)
if __name__ == ‘__main__‘:
    p = eat("nickle")
    p.daemon = True # 一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且主进程死,p跟着一起死
    p.start()

    p.join(0.0001) # 等待p停止,等0.0001秒就不再等了
    print("go")

"""
输出结果：
go
"""

# -*- coding:utf-8 -*-
# /user/bin/python
from multiprocessing import Process
import time
import random

class eat(Process):

    def __init__(self,name):
        # self.name=name
        # super().__init__() #Process的__init__方法会执行self.name=Piao-1,
        #                    #所以加到这里,会覆盖我们的self.name=name

        #为我们开启的进程设置名字的做法
        super().__init__()
        self.name = name

    def run(self):
        print("%s eating" % self.name)
        time.sleep(random.randint(1,3))
        print("%s eat end" % self.name)
if __name__ == ‘__main__‘:

    p = eat("nickle")
    p.start()
    print("主线程")
    print(p.pid)
    print(p.name)

"""
输出结果：
主线程
9100
nickle
nickle eating
nickle eat end
"""

1 Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

1 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。
如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
2 q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，
会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
3  
4 q.get_nowait():同q.get(False)
5 q.put_nowait():同q.put(False)
6 
7 q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
8 q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
9 q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

1 1 q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞
2 2 q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列
使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
3 3 q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为