初识进程 线程 协程（一）：进程

def func(n):
    ......
if __name__ == ‘__main__‘:
    p = Process(target=func, args = (1,))
    p.start()

m = 1
def task1(t):
    global m    # 由于m是不可变对象，所以设置全局变量
    while True:
        sleep(t)
        m += 1
        print(‘这是任务一。。。。。‘, os.getpid(), ‘---‘, os.getppid(), ‘m=‘, m)     # getpid得到当前进程pid，getppid得到父（主）进程的pid

def task2(t):
    global m
    while True:
        sleep(t)
        m += 1
        print(‘这是任务二。。。。。‘, os.getpid(), ‘---‘, os.getppid(), ‘m=‘, m)     # 子进程的ppid和父（主）进程的pid一致


n = 1
if __name__ == ‘__main__‘:
    p1 = Process(target=task1, name=‘任务1‘, args=(0.1,))  # 创建子进程
    p2 = Process(target=task2, name=‘任务2‘, args=(0.2,))

    p1.start()  # 开启一个进程，并执行run方法        ps：run（）：执行进程
    p2.start()

    print(os.getpid())  # 主进程的pid
    print(p1.name)
    print(p2.name)  # 主进程，先运行主进程，无论主进程在那个位置
    for i in range(5):
        n += 1
        m += 1
        sleep(0.2)
        print(‘主进程n={},m={}‘.format(n, m))
    else:
        p1.terminate()
        p2.terminate()

    print(‘-end-‘)

‘‘‘
运行结果：
1376
任务1
任务2
这是任务一。。。。。 14636 --- 1376 m= 2
主进程n=2,m=2
这是任务一。。。。。 14636 --- 1376 m= 3
这是任务二。。。。。 7912 --- 1376 m= 2
这是任务一。。。。。 14636 --- 1376 m= 4
主进程n=3,m=3
这是任务二。。。。。 7912 --- 1376 m= 3
这是任务一。。。。。 14636 --- 1376 m= 5
这是任务一。。。。。 14636 --- 1376 m= 6
主进程n=4,m=4
这是任务二。。。。。 7912 --- 1376 m= 4
这是任务一。。。。。 14636 --- 1376 m= 7
这是任务一。。。。。 14636 --- 1376 m= 8
主进程n=5,m=5
这是任务二。。。。。 7912 --- 1376 m= 5
这是任务一。。。。。 14636 --- 1376 m= 9
这是任务一。。。。。 14636 --- 1376 m= 10
主进程n=6,m=6
-end-
‘‘‘

class MyProcess(Process)：
    def __init__(self, n):
        super(MyProcess, self).__init__()
        self.n = n
    def run(self)：
        ......
if __name__ == ‘__main__‘:
    p = MyProcess(args = (1,))
    p.start()

def task(n):
　　......
def back(n):
　　......
if __name__ == ‘__main__‘:
　　p = Pool(5)
   lis = [...]
　　for i in lis:
　　　　# p.apply(target=task, args=(i,))    # 阻塞式
　　　　p.apply_async(target=task, args=(i,), callback=back)    # 非阻塞式,callbacka将target的返回结果传给back
　　　　pool.close()    # 添加任务结束
　　　　pool.join()     # 插在主进程前，执行完才可以执行主进程

def a(q):
    ......
    q.put(...)
    ......
def b(q):
    while not q.empty():
        .......
        q.get()
        ......        
if __name__ == ‘__main__‘:
    q = Queue(5)
    p1 = Process(target=a, args=(q,))
    p2 = Process(target=b, args=(q,))
    try:
        p1.start()
        p1.join()  # 进程会同时开始，这样p2就会用空队列开始执行，
        p2.start()
    except:
        print(‘发成错误‘)

q = Queue(2)
# print(q.get())　　# 在put之前使用get，会发生阻塞
q.put(1)
q.put(2)
# q.put(2)　　# 超出队列长度会发生阻塞
print(q.get())