day31 udp 与多进程

import socket
ip_port = (‘127.0.0.1‘,9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)

while True:
    data = sk.recv(1024)
    print data




import socket
ip_port = (‘127.0.0.1‘,9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
    inp = raw_input(‘数据：‘).strip()
    if inp == ‘exit‘:
        break
    sk.sendto(inp,ip_port)

sk.close()

UDP Demo

# 服务端
import socket
ip_port = (‘127.0.0.1‘,9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)

while True:
    data,(host,port) = sk.recvfrom(1024)
    print(data,host,port)
    sk.sendto(bytes(‘ok‘, encoding=‘utf-8‘), (host,port))


#客户端
import socket
ip_port = (‘127.0.0.1‘,9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
    inp = input(‘数据：‘).strip()
    if inp == ‘exit‘:
        break
    sk.sendto(bytes(inp, encoding=‘utf-8‘),ip_port)
    data = sk.recvfrom(1024)
    print(data)

sk.close()

UDP

from socket import *
import os
import json
import struct
import hashlib

server=socket(AF_INET,SOCK_STREAM)
server.bind((‘127.0.0.1‘,8000))
server.listen(5)


def get(filepath,conn):
    #制作报头
    header_dic={
        ‘filename‘:os.path.basename(filepath),# C:\\\\1.png
        ‘size‘:os.path.getsize(filepath),
    }
    header_json=json.dumps(header_dic)
    header_bytes=header_json.encode(‘utf-8‘)

    #先发送报头的长度
    conn.send(struct.pack(‘i‘,len(header_bytes)))

    #再发送报头
    conn.send(header_bytes)

    #再发送真实的数据
    with open(filepath,‘rb‘) as f:
        m=hashlib.md5()
        for line in f:
            conn.send(line)
            m.update(line)
    #最后发送md5值
    md5=m.hexdigest()
    print(md5)
    conn.send(md5.encode(‘utf-8‘))


while True:
    conn,addr=server.accept()
    while True:
        try:
            data=conn.recv(1024)
            cmd,filepath=data.decode(‘utf-8‘).split() #get C:\\\\1.png
            if cmd == ‘get‘:
                get(filepath,conn)
            if not data:break

        except Exception as e:
            print(e)
            break
    conn.close()

server.close()

from socket import *
import struct
import json
import hashlib

download_dir=r‘D:\\‘

client=socket(AF_INET,SOCK_STREAM)
client.connect((‘127.0.0.1‘,8000))

while True:
    cmd=input(‘>>: ‘).strip() #get a.txt
    if not cmd:continue
    client.send(cmd.encode(‘utf-8‘))
    #先收报头长度
    obj=client.recv(4)
    header_size=struct.unpack(‘i‘,obj)[0]

    #再收报头
    header_bytes=client.recv(header_size)
    header_json=header_bytes.decode(‘utf-8‘)
    header_dic=json.loads(header_json)

    filename=header_dic[‘filename‘]
    abs_path=r‘%s\%s‘ %(download_dir,filename)
    size=header_dic[‘size‘]
    print(header_dic)
    #再收真实数据
    recv_size=0
    with open(abs_path,‘wb‘) as f:
        m=hashlib.md5()
        while recv_size < size:
            if size - recv_size > 1024:
                line=client.recv(1024)
            else:
                line = client.recv(size-recv_size)
            f.write(line)
            m.update(line)
            recv_size+=len(line)
    client_md5=m.hexdigest()
    #最后收md5值
    server_md5=client.recv(1024).decode(‘utf-8‘)
    if client_md5 !=  server_md5:
        os.remove(abs_path)
        print(‘文件已损坏，请重写下载‘)



client.close()

考虑一个场景：浏览器，网易云音乐以及notepad++ 三个软件只能顺序执行是怎样一种场景呢？另外，假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入（I/O操作），而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。你是不是已经想到在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让程序B暂停。聪明，这当然没问题，但这里有一个关键词：切换。

既然是切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B所需要的系统资源（内存，硬盘，键盘等等）是不一样的。自然而然的就需要有一个东西去记录程序A和程序B分别需要什么资源，怎样去识别程序A和程序B等等(比如读书)。

进程定义：

进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程需要完成哪些功能以及如何完成；数据集则是程序执行过程中所需要使用的资源；进程数据块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

举例说明进程：想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他离开时的那一步继续做下去。