day17.网络编程2+进程

1 加入链接循环的套接字服务端

1.1 服务端

'''

2.1 基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信


2.2 基于网络类型的套接字家族
套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)



'''

import socket
#实例化得到一个对象
#type=socket.SOCK_STREAM   TCP服务端
#type=socket.SOCK_DGRAM   UDP服务端
server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

# 绑定地址和端口
server.bind(('127.0.0.1',80))

# listen:监听

server.listen(1)

# 等待用户连接
print('开始等待客户端连接了')
while True:
    sock,addr=server.accept()

    print(sock)
    print('客户端的地址是：',addr)

    data=sock.recv(1024)
    print(data)

    # 这不是字符串的upper
    sock.send(data.upper())

    sock.close()
server.close()

1.2 客户端

import socket

client=socket.socket()
client.connect(('127.0.0.1',80))

client.send('sb'.encode('utf-8'))

data=client.recv(1024)
print(data)

client.close()

2 加入通信循环的套接字服务端

2.1 服务端

import socket
server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

server.bind(('127.0.0.1',81))


server.listen(1)

print('开始等待客户端连接了')
while True:

    sock,addr=server.accept()
    print(sock)
    print('客户端的地址是：',addr)


    # 等待客户端发送过来的数据，如果客户端没有发送数据，会一直等着
    while True:
        try:
            data=sock.recv(1024)
            if len(data)==0: # 这个表示客户端正常断开了，结束通信循环
                break
            print(data.decode('utf-8'))
            sock.send(data.upper())
        except Exception as e:
            print(e) #客户端非正常断开，需要异常捕获
            break


    sock.close()
server.close()

2.2 客户端

  
import socket

client=socket.socket()
client.connect(('127.0.0.1',81))


while True:

    input_data=input('请输入发送给客户端的内容（输入q退出）：')

    if input_data=='q':
        break
    client.send(input_data.encode('utf-8'))

    data=client.recv(1024)
    print(data.decode('utf-8'))

client.close()

3 基于UDP的套接字客户端和服务端

3.1 服务端

import socket

# udp的服务端
server = socket.socket(type=socket.SOCK_DGRAM)

# 监听地址和端口
server.bind(('127.0.0.1', 82))

# 不需要listen，直接建立链接
print('等待客户端发送数据：')
while True:
#recvfrom回返回数据和客户端的地址
    data,addr = server.recvfrom(1024)
    print(data)
    print(addr)
    server.sendto(data.upper(), addr)

server.close()

3.2 客户端

import socket


client=socket.socket(type=socket.SOCK_DGRAM)
client.sendto(b'sb',('127.0.0.1',82))
# data,addr=client.recvfrom(1024)
# data,_=client.recvfrom(1024)
data=client.recv(1024)
print(data)
# print(addr)

client.close()

4 操作系统发展史

1 手工操作——穿孔卡片
	-用户独占全机
    -CPU的利用不充分
2 批处理
	-把一个操作整个写到磁带中，以后要进行这个操作，直接拿着磁带，读入即可
    -脱机批处理
    -联机批处理
    
3 多道程序系统
	-当一道程序因I/O请求而暂停运行时，CPU便立即转去运行另一道程序
    -各道程序轮流地用CPU，并交替运行
4 分时系统
	-多个程序在运行，时间片的概念，cpu执行完固定的时间，就会转去另一个程序
5 通用操作系统
	多道批处理系统，分时


io操作：（统统不占用cpu）
	键盘输入，从硬盘拿数据，从网络加载数据---》都叫输入
    显示在显示器，写到硬盘，从网络发送数据--->都叫输出

5 进程基础

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元


# 进程是资源分配的最小单位，线程是cpu执行的最小单位
#一个程序运行，最少有一个进程
#一个进程里最少有一条线程


# 进程和程序的区分
程序可以作为一种软件资料长期存在，而进程是有一定生命期的。
程序是永久的，进程是暂时的。


# 进程的状态（）
	-就绪态：可以被cpu调度执行了，还没有执行，排着队
    -运行态：在cpu中运行，正在运行（如果到了时间片，也会被调度出去，调度出去的程序是就绪态）
    -阻塞态：io操作，把数据加载到内存中

6 并发和并行

并发：你在跑步，鞋带开了，停下跑步，系鞋带，系完以后，继续跑步，在一个时间段内来看，你干了多个事
	-单核下的并发
并行：你在跑步，你用随身听在听着，同一时刻，在干多个事
	-只有多核才涉及到并行

7如何开启多进程

from multiprocessing import Process


#如果在win下开多进程，必须写main，否则报错
import time
def wirte_file(s):

    time.sleep(5)
    with open('a.txt','a') as f:
        f.write(s)
        f.write('\n')

if __name__ == '__main__':
    time.sleep(5)
    # wirte_file()
    # 开启多进程的第一个方式
    p=Process(target=wirte_file,args=['lqz is nb'])
    # 执行该进程
    p.start()


    # 又开了一个进程
    p1 = Process(target=wirte_file,args=['egon is dsb'])
    # 执行该进程
    p1.start()