python 创建进程 获取进程句柄 python获取进程号

1、进程概念

进程是一个执行中的程序，资源分配的最小单位。每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。在单核CPU系统中的多进程，内存中可以有许多程序，但在给定一个时刻只有一个程序在运行；就是说，可能这一秒在运行进程A，下一秒在运行进程B，虽然两者都在内存中，都没有真正同时运行。

2、获取进程号方法

"""
ps -aux 查看进程号
ps -aux | grep 2860
kill -9 2860  杀死进程
"""
# 获取当前进程id (子进程)
res = os.getpid()
print(res)

# 获取当前进程的父进程
res2 = os.getppid()
print(res2)

3、进程基本使用

from multiprocessing import Process
#1、创建基本进程
def func():
    print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))

# 为了解决windows 和 linux 系统的兼容问题,下面这句话必须加上,否则报错
if __name__ == "__main__":
    # 创建子进程,返回进程对象,执行func这个任务
    p = Process(target=func)
    # 调用子进程
    p.start()
#2、创建带有参数的进程
def func(n):
    for i in range(1,n+1):
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    n = 5
    #创建子进程
    p = Process(target=func,args=(n,))
    #调用子进程
    p.start()

    for i in range(1,n+1):        
        print("*" * i)
#3、进程间的数据彼此隔离
count = 10
def func():
    global count
    count += 1
    print("我是子进程count={}".format(count))

if __name__ == "__main__":
    p=Process(target=func)
    p.start()
    time.sleep(1)
    print(count)

4、相关信息

多个进程之间是异步并发的程序,因为cpu的调度策略问题,不一定哪个任务先执行,哪个任务后执行.
整体而言,主进程比子进程创建的速度要快,cpu遇到阻塞会立刻切换任务,等到阻塞态的任务变成了就绪态,cpu再回来执行

主程序会默认等到所有的子程序执行结束之后,在统一关闭程序,释放资源.
若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu,内存
增加系统的压力,所有方便于对进程的管理,主进程默认等待子进程.

5、join等待当前子进程全部执行完毕之后,主进程在执行(用来同步子父进程的)

from multiprocessing import Process
import time,os
# (1) join 基本语法
def func():
    print("发送第一封邮箱,要求张工资")
    
if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    
    # 必须等待子进程全部执行结束之后,在执行主进程中的代码,用join来同步子父进程.
    p.join()
    # time.sleep(1)
    print("发送第二封邮箱,涨到一个月6万")
    
# (2) 多个子进程的场景中使用join
def func(i):
    time.sleep(1)
    print("发送第%s封邮箱,要求升职加薪" % (i))
    
if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        lst.append(p)

    for i in lst:
        i.join()
        
    print("主进程发最后一封邮件:此致敬礼~")

6、使用自定义方法创建进程（必须继承Process这个父类，所有进程执行任务的逻辑必须写在run方法里面）

# 1.基本语法
class MyProcess(Process):
    def run(self):    
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))
        
if __name__ == "__main__":
    p = MyProcess()
    p.start()
    print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))    

# 2.带有参数自定类的方法
class MyProcess(Process):
    def __init__(self,arg):
        # 手动调用一下父类的构造方法(最终实现进程的创建)
        super().__init__()
        self.arg = arg

    def run(self):    
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))
        print(self.arg)
    
if __name__ == "__main__":
    p = MyProcess("我是传进来的参数")
    p.start()
    print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))

7、守护进程

守护进程守护的是主进程,如果主进程中的所有代码执行完毕了,
当前这个守护进程会被立刻杀死,立刻终止.
语法:
进程.daemon = True 设置当前这个进程为守护进程
必须写在start()调用进程之前进行设置

默认:主进程会默认等待所有子进程执行结束之后,在关闭程序,释放资源

from multiprocessing import Process
import time
# (1) 基本使用
def func():
    print("start当前子进程")
    time.sleep(1)
    print("end当前子进程")
if __name__ == "__main__":
    p = Process(target = func)
    p.daemon = True
    p.start()
    
    print("主进程执行结束 ... ")

# (2) 多个子进程的场景
def func1():
    count = 1
    while True:
        print("*" * count)
        time.sleep(0.5)
        count += 1
        
def func2():
    print("start func2 当前子进程任务")
    time.sleep(3)
    print("end   func2 当前子进程任务")

if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    
    # 设置p1这个进程对象为守护进程
    p1.daemon = True
    
    p1.start()
    p2.start()
    
    time.sleep(1)
    
    print("主进程执行结束 ... ")

8、锁

上锁和解锁是一对,只上锁不解锁会发生死锁现象(代码阻塞,不往下执行了)
互斥锁 : 互斥锁是进程之间的互相排斥,谁先抢到这个锁资源就先使用,后抢到后使用

from multiprocessing import Process,Lock
# 创建一把锁
lock = Lock()
# 上锁
lock.acquire()
# 连续上锁不解锁是死锁
# lock.acquire() error

print("运行中...")

# 解锁
lock.release()
print("执行程序 ... ")

9、信号量

信号量 Semaphore 本质上就是锁,只不过可以控制上锁的数量

Semaphore 可以设置上锁的数量
同一时间最多允许几个进程上锁
创建进程的时候,是异步并发
执行任务的时候,遇到锁会变成同步程序

from multiprocessing import Semaphore,Process
import time,random
sem = Semaphore(4)
sem.acquire()
# sem.acquire()
# sem.acquire()
# sem.acquire()
# sem.acquire() # 上第五把锁出现死锁状态.
print("执行响应的操作")
sem.release()

def ktv(person,sem):    
    sem.acquire()
    print("%s进入了ktv,正在唱歌" % (person))
    # 开始唱歌,唱一段时间
    time.sleep(random.randrange(3,7)) # 3 4 5 6 
    print("%s离开了ktv,唱完了" % (person))
    sem.release()
    
if __name__ == "__main__":
    sem = Semaphore(4)
    lst = ["ss","bb","dd"]
    for i in lst:
        p = Process(target=ktv,args=(i,sem))
        p.start()

10、事件(Event)

阻塞事件 ：
e = Event()生成事件对象e
e.wait()动态给程序加阻塞 , 程序当中是否加阻塞完全取决于该对象中的is_set() [默认返回值是False]
如果是True 不加阻塞
如果是False 加阻塞

控制这个属性的值
set()方法 将这个属性的值改成True
clear()方法 将这个属性的值改成False
 is_set()方法 判断当前的属性是否为True (默认上来是False)

from multiprocessing import Process,Event
import time,random
# 1基本使用

e = Event()
print(e.is_set())
e.wait()
print("程序运行中 ... ")

#2
e = Event()
e.set() # 将内部成员属性值由False -> True
print(e.is_set())
e.wait()
print("程序运行中 ... ")

e.clear() # 将内部成员属性值由True => False 
e.wait()
print("程序运行中2 ... ")

#3
e = Event()
# wait参数 可以写时间 wait(3) 代表最多等待3秒钟
e.wait(3) 
print("程序运行中3 ... ")

11、进程队列（可实现数据共享）

from multiprocessing import Process,Queue
import queue
"""队列特点: 先进先出,后进后出"""

q = Queue()
# 1.put 往队列中放值
q.put(100)
q.put(101)
q.put(102)

# 2.get 从队列中取值
res = q.get()
print(res)
res = q.get()
print(res)
# res = q.get()
# print(res)

# 3.队列中如果已经没有数据了,在调用get会发生阻塞.

res = q.get()
print(res)


# 4.get_nowait 存在系统兼容性问题[windows]好用 [linux]不好用 不推荐

res = q.get_nowait()
print(res)
try:
    res = q.get_nowait()
    print(res)
except queue.Empty:
    pass

# 5.设置队列的长度
"""设置队列长度最多存放4个元素"""

print("<======>")
q2 = Queue(4)
q2.put(200)
q2.put(201)
q2.put(202)
# q2.put(203)
# 如果超过了队列的指定长度,在继续存值会出现阻塞现象
# q2.put(204)

# 6.put_nowait() 非阻塞版本的put,超出长度后,直接报错
q2.put_nowait(204)
try:
    q2.put_nowait(205)
except queue.Full:
    pass

# ### 2.进程之间的数据共享
def func(q3):
    # 2.子进程获取数据
    res = q3.get()
    print(res)
    
    # 3.子进程存数据
    q3.put("马生平")

if __name__ == "__main__":
    q3 = Queue()
    p = Process(target=func,args=(q3,))
    p.start()
    
    # 1.主进程添加数据
    q3.put("王凡")
    
    # 为了等待子进程把数据放到队列中,需要加join
    p.join()
    
    # 4.主进程获取数据
    res = q3.get()
    print(res)
    
    print("主程序结束 ... ")

12、JoinableQueue

from multiprocessing import Process, JoinableQueue
import time,random
"""
put 存储
get 获取
task_done 
join

task_done 和 join 配合使用的
队列中 1 2 3 4 5
put 一次 内部的队列计数器加1
get 一次 通过task_done让队列计数器减1
join函数,会根据队列计数器来判断是阻塞还是放行
    队列计数器  = 0 , 意味着放行
    队列计数器 != 0 , 意味着阻塞
"""

# 基本语法
"""
jq =JoinableQueue()
jq.put("a")
print(jq.get())
# 通过task_done让队列计数器减1
jq.task_done()
jq.join()
print("finish")
"""

13、 Manager ( list 列表 , dict 字典) 进程之间的共享数据(列表或者字典等)

rom multiprocessing import Process,Manager,Lock

def work(data,lock):

    # 1.正常写法
    """
    # 上锁
    lock.acquire()
    # 修改数据
    data["count"] -= 1
    # 解锁
    lock.release()
    """
    
    # 2.使用with语法可以简化上锁和解锁两步操作
    with lock:
        data[0] += 1

if __name__ == "__main__":
    lst = []
    lock = Lock()
    m = Manager()
    data = m.dict( {"count":20000} )
    data = m.list( [1,2,3] )
    for i in range(50):
        p = Process(target=work,args=(data,lock))
        p.start()
        lst.append(p)
        
    # 确保所有进程执行完毕之后,在向下执行,打印数据,否则报错.
    for i in lst:
        i.join()
        
    print(data)

 14、实现进程间通讯多种方式

管道，消息队列，共享内存

一、python中进程间通过管道的方式进行通信。创建一个管道，在进程的一端发送消息，在进程的另一端接收消息，通过这个内置的方法实现通信。一端发出消息，另一端接收消息。写法也比较简单，在上一篇文章中有对应示例。这里不再多做示例。

二、消息队列。创建一个中间容器，一端向中间容器中写入数据，另一端则去获取容器中数据，通过设置中间容器的方式实现通信。在这里我没有说明队列，而是用容器，而是因为其他容器也可以替代队列，只是队列在这里有一个极大的优势，就是队列中的数据有且只能取用一次，用完就没有了，所以不会出现重复。在这里就变的有优势。其实如果只是为了通信，也为了常规使用方便，或者控制更加精细，可以选择自己熟悉的容器都是可以的。如列表、元组、字典等其实都是可以的。就只是一端把数据放到中间容器中，另一商从中间容器中去获取即可。（在这里也不做演示，原理理解了，实现就只是技术上一的个小问题而已）。

三、共享内存。创建一个内存空间，然后向共享内存中写入数据，一端写入一端读取，通过这样的方式来实现内存共享。