python进程

1、操作系统的作用

隐藏丑陋复杂的硬件接口，提供良好的抽象接口

管理调度进程，让进程对硬件的竞争变得有序

2、进程的调度算法

FCFS先来先服务调度算法

段作业优先调度算法

时间片轮转法

多级反馈队列

3、进程的并行与并发

并行：是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。（资源够用，比如三个线程，四核的CPU ）

并发：是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个session。

4、同步和异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

同步：一个进程的执行依赖于另外的进程，只有被依赖的进程执行完，自己的任务才执行。

异步：只通知被以来的进程完成什么工作，不需要等待被以来的进程完成。

5、开一个多进程

from  multiprocessing  import Process
def func(i):
    print("输出：%s"%i)
if __name__ == '__main__':
    for  i in range (10):
        p=Process(target=func,args=(i,))
        p.start()
    print("你好")

p.join()的使用

p.join()感知一个子进程的结束，将异步程序同步

from  multiprocessing  import Process
import time
def func(i):
    print("输出：%s"%i)
if __name__ == '__main__':
    p_list=[]
    for  i in range (20):
        p=Process(target=func,args=(i,))
        p_list.append(p)
        p.start()
    for p  in p_list:  #[p.join() for p  in p_list]
        p.join()
    print('结束')

用类的方式开启一个多进程的第二种方式

from multiprocessing import Process
import os
class Myprocess(Process):
  def run(self):
    print(os.getpid())
if __name__ == '__main__':
    for  i  in  range(20):
        print('主',os.getpid())
        p1=Myprocess()
        p1.start()

自定义继承类中必须有一个run方法，run方法是在子进程中自行的程序

打印进度条

import time
def run(i):
    num=str(i)
    print('*'*i+num+'%',end='\r')
for  i  in  range(101):
    run(i)
    time.sleep(0.1)

6、使用多进程实现socket服务端的并发效果

server端

import socket
from  multiprocessing  import Process
def  server(conn):
    conn.send('你好'.encode('utf-8'))
    info = conn.recv(1024).decode('utf-8')
    print(info)
    conn.close()
 
if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1',8080))
    sk.listen()
    while True:
        conn,addr = sk.accept()
        q = Process(target=server,args=(conn,))
        q.start()
    sk.close()

client端

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
ret = sk.recv(1024).decode('utf-8')
print(ret)
msg = input("》》》》").encode('utf-8')
sk.send(msg)
sk.close()

主进程在执行完自己的代码之后，不会立马结束，而是等待子进程结束之后，回收子进程资源

7、守护进程

由子进程 转化而来   伴随着主进程的结束而结束

from  multiprocessing  import Process
import time
def func():
    for i in range (10):
        time.sleep(1)
        print("输出：%s"%i)
if __name__ == '__main__':
        p=Process(target=func)
        p.daemon = True
        p.start()
        for i in range (10) :
            print("你好%s"%i)
            time.sleep(0.5)

p.terminate()结束一个子进程

if __name__ == '__main__':
        p=Process(target=func)
        p.daemon = True
        p.start()
        print(p.is_alive())  #  判断一个进程是否活着
        p.terminate()    # 关闭一个子进程
        time.sleep(0.5)
        print(p.name)   # 查看进程的名字
        print(p.is_alive())

8、进程锁

相当于将异步的程序变成同步

对程序加锁，同一时间只能有一个进程执行程序

from  multiprocessing  import Process,Lock
import time
def func(i,lock):
        lock.acquire()
        time.sleep(1)
        print("输出：%s"%i)
        lock.release()
if __name__ == '__main__':
        lock = Lock()
        for  i in range (10):
            p=Process(target=func,args=(i,lock))
            p.start()

9、信号量

规定同一时间允许几个进程来同时执行程序

from  multiprocessing  import Process,Semaphore
import time
def func(i,sem):
        sem.acquire()
        time.sleep(1)
        print("输出：%s"%i)
        sem.release()
if __name__ == '__main__':
        sem = Semaphore(3)
        for  i in range (10):
            p=Process(target=func,args=(i,sem))
            p.start()

10、Event事件

from  multiprocessing  import Event
e = Event()  #实例化   默认阻塞状态
print(1111111)
e.set() # 将事件改为true
print(e.is_set()) # 打印事件的状态
e.wait()
print(22222)
e.clear() #将事件改为False
e.wait()
print(33333)

使用事件实现红绿灯

import time
from multiprocessing import Event, Process
def light(e):
    while True:
        if e.is_set():
            e.clear()
            print('\033[31m红灯亮了\033[0m')
            time.sleep(2)

        else:
            e.set()
            print('\033[32m绿灯亮了\033[0m')
            # print('\033[31m红灯亮了\033[0m')
            time.sleep(2)
            # print('\033[32m绿灯亮了\033[0m')
def car(e, i):
    if not e.is_set():
        print('%s车在等待' % i)
    e.wait()
    print('%s车通过' % i)
if __name__ == '__main__':
    e = Event()
    p1 = Process(target=light, args=(e,))
    p1.start()
    for i in range(20):
        time.sleep(0.5)
        p2 = Process(target=car, args=(e, i))
        p2.start()