学习日记26

今日内容

同步异步阻塞非阻塞

并行：指的是两者同时执行，比如赛跑
并发：指的是在资源有限的情况下，两者交替轮流使用资源
​
同步：一个任务如果需要依赖另一个任务的完成，就会等到另一个任务完成才会完成现在的任务
异步：一个任务如果需要依赖另一个任务的完成，就会优先完成手上的任务，再等到另一个任务完成
​
阻塞：等待另一个任务完成的状态叫作阻塞
非阻塞：等待的时候时不时的查询另一个任务的完成情况
​
效率最低的同步阻塞
效率最高的异步非阻塞
​

开启进程

from multiprocessing import Process
def write():
    with open('abc','a')as f:
        f.write('a')
        f.write('\n')
​
# window中要想开启进程，必须放在main里
if __name__ == '__main__':
    # 1.开启进程先实例化，得到进程对象
    # target => 你要执行的任务
    # 通知操作提现开启进程
    p = Process(target = write)
    # 2.必须调用start方法
    p.start()

process类

process类的参数
target ：指定你要执行的任务
name ：进程名
arge ：传位置参数
kwarge ：以字典的方式传参数
​
process类的方法
p.start() 开启进程必须使用
p.join() 等待子进程执行完毕再执行主进程
p.run() 调用run方法不会启动子进程，第二种开启进程的方式，需要用到run方法，重写run方法
p.terminate() 杀死进程
p.is_alive() 判断进程是否存活
​
process类的属性
p.name 进程名
p.pid 进程id号
p.daemon = True 设置守护进程 主进程结束，子进程也结束，必须放在start之前

获取进程id号

import os
def write():
    print('子进程的id号%s' % os.getpid())
    print('父进程的id号%s' % os.getppid())

同时运行多个进程

def write(i):
    time.sleep(1)
    print('i')
    
if __name__ == '__main__':
    # 同时运行5个进程
    for i in range(5):
        p = Process(target = write,arge = (i))
        p.start()
        
        
# 同时运行5个进程，并且顺序执行        
def write(i):
    time.sleep(1)
    print('i')
    
if __name__ == '__main__':
    ll = []
    for i in range(5):
        p = Process(target = write,arge = (i))
        p.start()
        ll.append(p)
    for j in ll:
        j.join()

高并发下的tcp服务端

import socket
from multiprocessing import Process
​
def task(sock):
    while True:
        try:
            data = sock.recv(1024)
            if len(data) == 0:
                break
            print(data)
            sock.send(data.upper())
        except Exception as e:
            print(e)
            break
    sock.close()
if __name__ == '__main__':
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    print('正在接受消息')
    while True:
        sock, addr = server.accept()
        print(sock)
        print(addr)
        p = Process(target = task,args = sock)
        p.start()
    server.close()

进程锁

import os,time
from multiprocessing import Process,lock
​
def task(lock):
    # 上锁
    lcok.acquire()
    print('进程id%s 开始执行了' % os.getpid())
    time.sleep(2)
    print('进程id%s 结束执行了' % os.getpid())
    # 释放锁
    lock.release
    
if __name__ == '__main__':
    # 实例化得到一把锁,5个进程用一把锁
    lock = lock()
    for i in range(5):
        p = Process(target = task)
        p.start