python_进程

import time
import multiprocessing
# process = Process(target =函数，name = 进程的名字，args=（给函数传递的参数）)
# process 对象
# 对象的调用方法：
# process.start() 启动进程并执行任务
# process.run 只是执行了任务但没有启动进程
# terminate 终止

#进程创建
import os
def task1(s):
    while True:
        time.sleep(s)
        print('task 1',os.getpid(),os.getppid()) #pid 当前进程号，ppid当前父进程号

def task2(s,name):
    while True:
        time.sleep(s) # args=(s,)
        print('task 2',os.getpid(),os.getppid(),name) # args='aa'


number =1
if __name__ == '__main__':
    #test.py 为父进程
    # 子进程
    p1 = multiprocessing.Process(target=task1,name='任务1',args=(1,)) # target=函数名，不加()，若加()传递的是函数调用后的结果
    p1.start()
    print(p1.name)
    p2 = multiprocessing.Process(target=task2,name='任务2',args=(1,'aa'))# Process 生成进程, name 为当前进程的名字,#args= 作为参数传入上头s及name
    p2.start()
    print(p2.name)

    while True:
        number += 1
        time.sleep(0.1)
        if number ==100:
            p1.terminate()
            p2.terminate()
            break
        else:
            print(number)

import time
import multiprocessing

#进程创建

m =1
# 对于进程中的全局变量，不共享
def task1(s):
    global m
    while True:
        time.sleep(s)
        m += 1
        print('task 1',m)

def task2(s):
    global m
    while True:
        time.sleep(s)
        m += 1
        print('task 2',m)



if __name__ == '__main__':
    #test.py 为父进程
    # 子进程
    p1 = multiprocessing.Process(target=task1,name='任务1',args=(1,))
    p1.start()

    p2 = multiprocessing.Process(target=task2,name='任务2',args=(2,))
    # Process 生成进程, name 为当前进程的名字,#args= 作为参数传入上头s及name
    p2.start()


    while True:
        time.sleep(3)
        m +=1
        print('main:',m)
----------------------------------------------------
task 1 2
task 1 3task 2
 2
main: 2
task 1 4
task 2 3
task 1 5
task 1 6
main: 3
task 2 4
task 1 7
task 1 8

import time
import multiprocessing
# process = Process(target =函数，name = 进程的名字，args=（给函数传递的参数）)
# process 对象
# 对象的调用方法：
# process.start() 启动进程并执行任务
# process.run 只是执行了任务但没有启动进程
# terminate 终止

#进程创建
import os
def task1(s):
    while True:
        time.sleep(s)
        print('task 1',os.getpid(),os.getppid()) #pid 当前进程号，ppid当前父进程号

def task2(s,name):
    while True:
        time.sleep(s) # args=(s,)
        print('task 2',os.getpid(),os.getppid(),name) # args='aa'


number =1
if __name__ == '__main__':
    #test.py 为父进程
    # 子进程
    p1 = multiprocessing.Process(target=task1,name='任务1',args=(1,))
    p1.start()
    print(p1.name)
    p2 = multiprocessing.Process(target=task2,name='任务2',args=(1,'aa'))# Process 生成进程, name 为当前进程的名字,#args= 作为参数传入上头s及name
    p2.start()
    print(p2.name)

    while True:
        number += 1
        time.sleep(0.1)
        if number ==100:
            p1.terminate()
            p2.terminate()
            break
        else:
            print(number)
-----------------------------------------------
任务1
任务2
2
3
4
5
6
7
8
9
10
task 2 34204 25548 aa
task 1 31716 25548
11
12
13
14
15
16
17
18
19
task 2 34204 25548 aa
task 1 31716 25548
20
21
22
23
24
25
26
27
28
task 2 34204 25548 aa
task 1 31716 25548
29
30
31

---

进程池：

        当需要创建的子进程数量不多，可以使用multiprocessing中的Process动态生成多个进程，但是目标多时，则利用Pool方法。

        初始化Pool时，可以指定一个最大进程数，当有新的请求到pool时，如果池没满，则会创建一个新的进程来响应请求，如果池已经达到指定最大值，请求就会等待，直到池中有其他进结束，才会执行。

进程池：

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

        pool.apply()阻塞

        pool.apply_async()非阻塞

        pool.close()停止添加

        pool.join 让主进程让步

        

非阻塞式：

import  multiprocessing,time,os
from random import random

def task(taskname):
    print('开始任务',taskname)
    start = time.time()
    #使用sleep
    time.sleep(random()*2) # 随机停歇一段时间
    end = time.time()
    print('结束任务',taskname,'时长:',(end - start),'进程id：',os.getpid())


if __name__ == '__main__':
    pool = multiprocessing.Pool(5)
    tasks = ['吃饭','睡觉','打豆豆','听歌','看电影','读书']
    for i in tasks:
        pool.apply_async(task,args=(i,))   # 阻塞式

    #必须添加以下两句，否则直接执行 print('over')
    pool.close() # 添加任务结束
    pool.join()

    print('over')
------------------------------------------------------------------------
开始任务 吃饭
开始任务 睡觉
开始任务 打豆豆
开始任务 听歌
开始任务 看电影
结束任务 睡觉 时长: 1.0555424690246582 进程id： 27916
开始任务 读书
结束任务 打豆豆 时长: 1.1265671253204346 进程id： 23288
结束任务 听歌 时长: 1.1395740509033203 进程id： 34624
结束任务 看电影 时长: 1.324636459350586 进程id： 18152
结束任务 吃饭 时长: 1.4500024318695068 进程id： 29340
结束任务 读书 时长: 1.1366159915924072 进程id： 27916
over

import  multiprocessing,time,os
from random import random

def task(taskname):
    print('开始任务',taskname)
    start = time.time()
    #使用sleep
    time.sleep(random()*2) # 随机停歇一段时间
    end = time.time()
    #print('结束任务',taskname,'时长:',(end - start),'进程id：',os.getpid())
    return '结束任务',taskname,'时长:',(end - start),'进程id：',os.getpid()

container = [] #列表可变，不需调global
def callback_func(n):
    container.append(n)

if __name__ == '__main__':
    pool = multiprocessing.Pool(5)
    tasks = ['吃饭','睡觉','打豆豆','听歌','看电影','读书']

    #非阻塞式
    for i in tasks:
        pool.apply_async(task,args=(i,),callback=callback_func) #callback 回调

    #必须添加以下两句，否则直接执行 print('over')
    pool.close() # 添加任务结束
    pool.join()

    for c in container:
        print(c)


    print('over')
---------------------------------------------------------------------
开始任务 吃饭
开始任务 睡觉
开始任务 打豆豆
开始任务 听歌
开始任务 看电影
开始任务 读书
('结束任务', '睡觉', '时长:', 0.982391357421875, '进程id：', 20936)
('结束任务', '吃饭', '时长:', 1.2418849468231201, '进程id：', 28024)
('结束任务', '看电影', '时长:', 1.2558932304382324, '进程id：', 32456)
('结束任务', '听歌', '时长:', 1.2618944644927979, '进程id：', 1776)
('结束任务', '打豆豆', '时长:', 1.887202262878418, '进程id：', 29632)
('结束任务', '读书', '时长:', 1.291977882385254, '进程id：', 20936)
over

阻塞式：

特点：添加一个，执行一个任务，如果一个任务不结束，另一个任务就进不来

import  multiprocessing,time,os
from random import random

def task(taskname):
    print('开始任务',taskname)
    start = time.time()
    #使用sleep
    time.sleep(random()*2) # 随机停歇一段时间
    end = time.time()
    print('完成任务{},时长{},进程id{}'.format(taskname,(end - start),os.getpid()))
  




if __name__ == '__main__':
    pool = multiprocessing.Pool(5)
    tasks = ['吃饭', '睡觉', '打豆豆', '听歌', '看电影', '读书']
    # 阻塞式
    for i in tasks:
        pool.apply(task,args=(i,)) #callback 回调
    pool.close()  # 添加任务结束
    pool.join()
    print('over')
-----------------------------------------------------------------------------
开始任务 吃饭
完成任务吃饭,时长1.4492807388305664,进程id11132
开始任务 睡觉
完成任务睡觉,时长0.07950091361999512,进程id9604
开始任务 打豆豆
完成任务打豆豆,时长0.2515096664428711,进程id31108
开始任务 听歌
完成任务听歌,时长0.4940202236175537,进程id31688
开始任务 看电影
完成任务看电影,时长1.12396240234375,进程id12708
开始任务 读书
完成任务读书,时长1.3488681316375732,进程id11132
over

---

进程间通信：

from multiprocessing import Queue

q = Queue(5) # 总共加5次，F超过，一直等待
q.put('A')
q.put('B')
q.put('C')
q.put('D')
q.put('E')
print(q.qsize())
q.put('F') # put() 如果queue满了则只能等待，除非有'空地'则添加成功
-------------------------------------------
结果如下

==================================================================

from multiprocessing import Queue

q = Queue(5) # 总共加5次，F超过，一直等待
q.put('A')
q.put('B')
q.put('C')
q.put('D')
q.put('E')
print(q.qsize())
if not q.full():  # q.empty() 判断队列是否为空
    q.put('F',timeout=3) # put() 如果queue满了则只能等待，除非有'空地'则添加成功
else:
    print('队列已满')
------------------------------
5
队列已满

 

from multiprocessing import Queue,Process
import time

def download(q):
    photo = ['girl.jpg','man.jpg','dog.jpg']
    for i in photo:
        print('下载照片{}完成'.format(i))
        time.sleep(0.5)
        q.put(i)
def getph(q):
    while True:
        try:
            file = q.get(timeout=2)
            print('获取照片{}'.format(file))
        except:
            print('所有照片打印完成')
            break

if __name__ == '__main__':
    q = Queue(5)
    p1 = Process(target=download,args=(q,))
    p2 = Process(target=getph,args=(q,)) # 共享q

    p1.start()
    p2.start()
--------------------------------------------------
下载照片girl.jpg完成
下载照片man.jpg完成
获取照片girl.jpg
下载照片dog.jpg完成
获取照片man.jpg
获取照片dog.jpg
所有照片打印完成