python-day33-36_socket验证客户端合法性_多进程

1，验证客户端合法性

server:

import hmac
import socket
import os

secret_key = b'egg'
def check_conn(conn):
    msg = os.urandom(32)        # 随机产生32个字节的bytes类型字符串
    conn.send(msg)
    h = hmac.new(secret_key,msg)        # 默认MD5摘要。参数必须是bytes类型
    digest = h.digest()　　　　# MD5是128位长度摘要
    client_digest = conn.recv(1024)
    return hmac.compare_digest(digest,client_digest)

sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()
conn,addr = sk.accept()
res = check_conn(conn)
if res:
    print('合法客户端')
    conn.close()
else:
    print('不合法的客户端')
    conn.close()

 

client:

import hmac
import socket

secret_key = b'egg'
sk = socket.socket()
sk.connect(('127.0.0.1',8090))
msg = sk.recv(1024)
h = hmac.new(secret_key,msg)
digest = h.digest()
sk.send(digest)
sk.close()

 

2，多客户端同时连接

server:

import socketserver
import struct
class Myserver(socketserver.BaseRequestHandler):        # 父类是固定的
    def handle(self):    # 这个函数名也是固定的
        myname = 'server:'
        myname_len = len(myname.encode('utf-8'))
        print('{}会话已连接'.format(__name__))
        while True:
            mesg = input('>>>')
            buffer = struct.pack('i',myname_len)
            self.request.send(buffer)
            self.request.send(myname.encode('utf-8'))
            buffer = struct.pack('i', len(mesg.encode('utf-8')))
            self.request.send(buffer)
            self.request.send(mesg.encode('utf-8'))
            if mesg == 'q':
                print('{}会话已关闭'.format(__name__))
                break
            ret = self.request.recv(4)
            buffer = struct.unpack('i',ret)[0]
            ret1 = self.request.recv(buffer).decode('utf-8')
            ret = self.request.recv(4)
            buffer = struct.unpack('i',ret)[0]
            ret2 = self.request.recv(buffer).decode('utf-8')
            print(ret1+ret2)
            if ret2 == 'q':
                print('{}会话已关闭'.format(__name__))
                break
server = socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver)   # 创建多线程sock服务对象
server.serve_forever()  # 起用服务。在一个客户端结束后，当前服务器端继续运行，与其他的客户端继续进行通话。

# if __name__ == '__main__':
#     server = socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver)

 

client:

import socket
import struct
sk = socket.socket()
sk.connect(('127.0.0.1',9000))
myname = '大众点评:'
myname_len = len(myname.encode('utf-8'))
while True:
    ret = sk.recv(4)
    buffer = struct.unpack('i',ret)[0]
    ret1 = sk.recv(buffer).decode('utf-8')
    ret2 = sk.recv(4)
    buffer = struct.unpack('i',ret2)[0]
    ret3 = sk.recv(buffer).decode('utf-8')
    print(ret1+ret3)
    if ret3 == 'q':
        print('{}会话已关闭'.format(__name__))
        break
    mesg = input('>>>')
    buffer = struct.pack('i', myname_len)
    sk.send(buffer)
    sk.send(myname.encode('utf-8'))
    buffer = struct.pack('i', len(mesg.encode('utf-8')))
    sk.send(buffer)
    sk.send(mesg.encode('utf-8'))
    if mesg == 'q':
        print('{}会话已关闭'.format(__name__))
        break
sk.close()

正常的socket客户端代码

 

3，多进程

import os
import time
from multiprocessing import Process
def func(args,args2):
    print(args,args2)
    time.sleep(3)
    print('子进程 :', os.getpid())
    print('子进程的父进程 :', os.getppid())
    print(12345)

if __name__ == '__main__':
    p = Process(target=func,args=('参数','参数2'))   # 注册，参数是一个元组
    # p = Process(target=func,args=(111,))
    # p是一个进程对象,还没有启动进程
    p.start()       # 开启了一个子进程
    print('*'*10)
    print('父进程 :',os.getpid()) # 查看当前进程的进程号
    print('父进程的父进程 :',os.getppid()) # 查看当前进程的父进程

 

# 进程的生命周期
　　# 主进程
　　# 子进程
　　# 开启了子进程的主进程 :
　　　　# 主进程自己的代码如果长,等待自己的代码执行结束,
　　　　# 子进程的执行时间长,主进程会在主进程代码执行完毕之后等待子进程执行完毕之后 主进程才结束

 

4，join()

阻塞当前进程，直到调用join方法的那个进程执行完，再继续执行当前进程

from multiprocessing import Process
def func(args):
    print(args)
    print(12450)

if __name__ == '__main__':
    p_lst = []
    for i in range(1,10):
        p = Process(target=func,args=('-'*10*i,))
        p_lst.append(p)
        p.start()
        # p.join()    # 阻塞当前进程，直到调用join方法的那个进程执行完，再继续执行当前进程
    [i.join() for i in p_lst]
    print('主程序结束了')

 

5，开多进程的第二种方式

import os
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self):
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)

if __name__ == '__main__':
    p1 = MyProcess(1,2)
    p1.start()
    p2 = MyProcess(3,4)
    p2.start()

# 自定义类 继承Process类
# 必须实现一个run方法,run方法中是在子进程中执行的代码

 

6，进程间的数据隔离

主进程和子进程之间，数据是隔离的

import os
from multiprocessing import Process

def func():
    global n   # 声明了一个全局变量
    n = 0       # 重新定义了一个n
    print('pid : %s'%os.getpid(),n)

if __name__ == '__main__':
    n = 100
    p = Process(target=func)
    p.start()
    p.join()
    print('主',os.getpid(),n)

 

7，守护进程

import time
from multiprocessing import Process

def func():
    while True:
        time.sleep(0.2)
        print('我还活着')

def func2():
    print('in func2 start')
    time.sleep(8)
    print('in func2 finished')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True   # 设置子进程为守护进程，在start()之前开
    p.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()     # 结束一个子进程
    time.sleep(1)
    print(p2.is_alive())  # 检验一个进程是否还活着
    print(p2.name)

# 守护进程 会迫使对应的子进程，随着主进程的代码执行完毕 而 结束
# 在主进程内结束一个子进程 p.terminate()
　　# 结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程
# 检验一个进程是否活着的状态 p.is_alive()
# p.name p.pid 这个进程的名字和进程号

 

8，锁

# 火车票
import json
import time
from multiprocessing import Process
from multiprocessing import Lock

# def show(i):
#     with open('ticket') as f:
#         dic = json.load(f)
#     print('余票: %s'%dic['ticket'])

def buy_ticket(i,lock):
    lock.acquire() 　　#拿钥匙进门，其它人没有钥匙进不了
    with open('ticket') as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic['ticket'] > 0 :
        dic['ticket'] -= 1
        print('\033[32m%s买到票了\033[0m'%i)
    else:
        print('\033[31m%s没买到票\033[0m'%i)
    time.sleep(0.1)
    with open('ticket','w') as f:
        json.dump(dic,f)
    lock.release()      # 还钥匙

if __name__ == '__main__':
    # for i in range(10):
    #     p = Process(target=show,args=(i,))
    #     p.start()
    lock = Lock()
    for i in range(10):
        p = Process(target=buy_ticket, args=(i,lock))
        p.start()

 

转载于:https://www.cnblogs.com/yygy/p/10371234.html