高并发下的TCP服务端

并发

一个时间段看起来是同时执行

并行

实际意义上的同时运行

同步

让其做某件事，等它做完再开始接下来工作

异步

让其做某件事，它做它的，我们去忙自己的

阻塞

让其做某件事，什么都不做，等它做事的过程中 状态 叫做阻塞

非阻塞

让其做某件事，等它做事的过程中，在反复确认工作是否完成的状态

同步阻塞

让其做某件事，也不询问，等它做完，再开始接下来工作

异步非阻塞

让其做某件事，做事的过程中，我们去忙自己的，期间反复去询问有没有完成

开启进程

from multiprocessing import Process

import time
def write():
    time.sleep(1)
    with open('aa', 'a') as f:
        f.write('wuc 18\n')

windows中要想开启进程，必须放在main里进行
if __name__ == '__main__':
    1.开启进程先实例化，得到进程对象
    targrt=>你要执行的任务，，函数
    p = Process(target=write)
    2.必须调用start方法
    p.start()
    
    p1 = Process(target=write)
    p1.start()

Process参数

from multiprocessing import Process

import time
def write(name,age):
    print(name)
    print(age)
    # print(name)
    # time.sleep(1)
    # with open('aa', 'a') as f:
    #     f.write('wuc 18\n')


if __name__ == '__main__':
    p = Process(target=write, name='wuc_1',args=('wuc',18),kwargs={'name':'wuc','age':19})

    p.start()
    # print(p.name)
    
    name=***可以修改进程名
    args=***,按照位置进行传参,
    kwargs=***,按照字典进行传参

Process类的方法

p.run() 调用run方法，不会启动子进程，，第二种开启进程的方式，需要用到run方法， 重写run方法

p.join() 等待子进程执行完毕，在执行主进程

print(p.is_alive()) 打印出判断是否进程还存活  True
p.terminate()       终止进程
time.sleep(1)       让计算机有执行的时间
print(p.is_alive())  False  被“杀死”

Process类的属性

p.pid    pid号
p.name   进程名
p.daemon  设置守护进程，主进程结束，子进程结束，，**必须放在start前面

获取进程的id号

import os


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


if __name__ == '__main__':
    p = Process(target=write, args=('wuc',))

    p.start()
    print(p.pid)     #   write_子进程id号 与之相等
    print('main_主进程id号：%s' % os.getpid())   #  write_父进程id号 与之相等
    print('main_父进程id号：%s' % os.getppid())  # pycharm软件的id号
    
    

同时运行多个进程

def write(i, ):
    print('第%s个进程'% i)
    time.sleep(1)
    


if __name__ == '__main__':
    ll = []
    for i in range(5):
        p = Process(target=write, args=(i,))
        p.start()
        ll.append(p)
        
    for j in ll:
        j.join()

高并发下的TCP服务端

                             ***可实现多个客户端同时请求服务端***
def task(sock):
    while True:
        try:
            date = sock.recv(1024)
            if len(date) == 0:
                break
            print(date)
            sock.send(date.upper())
        except Exception as e:
            print(e)
            break
    sock.close()


if __name__ == '__main__':
    server = socket.socket()
    server.bind(('127.0.0.1', 8081))
    server.listen(5)
    print('正在接收客户端信息：')
    while True:
        sock, addr = server.accept()
        print(sock)
        print(addr)
        p = Process(target=task, args=(sock,))
        p.start()

    server.close()

进程锁

from multiprocessing import Process, Lock
import os
import time

def task(i, lock):
    lock.acquire()
    time.sleep(2)
    print('第%s个进程id：%s开始执行了' % (i, os.getpid()))
    print('第%s个进程id：%s结束执行了' % (i, os.getpid()))

    lock.release()


if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        p = Process(target=task, args=(i, lock))
        p.start()