164 网络编程小结

一、网络编程小结

二、网络架构及其演变过程

2.1 单机架构

不需要联网

2.2 CS架构

客户端直接和服务端交互

2.3 BS架构

客户端嫁接在浏览器上,浏览器和服务端交互

三、互联网和互联网的组成

3.1 教材版

边缘部分:服务端和客户端
核心部分:路由器/基站

3.2 科普版

硬件:网工的事情
软件:一大堆协议

四、大白话OSI七层协议

4.1 物理层

硬件,传输电信号

4.2 数据链路层

对电信号分组

以太网头:head

发送地址(mac地址):

接收地址(mac地址):

数据类型:

data

mac地址可以确定唯一的计算机

4.3 网络层

对电信号分组

head

以太网头:

发送地址(ip地址):

接收地址(ip地址):

data

互联网就是多个局域网,局域网通过路由器连接

ip地址+mac地址找到全世界独一无二的计算机

4.4 传输层

找到一个应用程序,每一个应用程序都会有一个独一无二的端口

ip地址+mac地址+端口找到全世界独一无二的计算机的唯一的应用程序

4.5 应用层

数据交互

五、Socket抽象层

应用程和传输层之间,你就是写了一个应用程序,服务端和客户端就是一个应用程序

六、TCP协议的三次握手和四次挥手

6.1 三次握手建立连接

客户端像服务端发出连接的带上SYN的请求给服务端
服务接收到后,返回一个带上SYN和ACK的请求给客户端
客户端进入连接状态,并且发送一个带上ACK的请求给服务端
服务端收到进入连接状态

6.2 四次挥手断开连接

客户端发出带有FIN的请求给服务端
服务端返回一个带有ACK的请求个客户端,说他已经知道了

然后服务端还有可能会有遗留的数据返回给客户端,会在这个时候发完

服务端发完之后才会发送一个带有FIN和ACK的请求给客户端

如果客户端没有接收到这条请求,就没有第四条请求给服务端,服务端会隔一段时间再发一次带有FIN和ACK的请求给客户端...如果在2MSL时间内,客户端一直没有响应,则强行关闭

客户端返回一个带有ACK请求给服务端,连接正常关闭

七、基于TCP协议的socket套接字编程

7.1 服务端

import socket

# 1. 符合TCP协议的手机
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # TCP

# 2. 绑定手机号 110
server.bind(('127.0.0.1', 8000))  # 127.0.0.1代表本地
# server.bind(('192.168.11.210',8000))  # 127.0.0.1代表本地

server.listen(5)  # 半连接池

# 3. 等待客户端连接
print('start...')
# 链接循环


while True:
    # 通信循环
    conn, client_addr = server.accept()
    while True:
        try:
            # 4. 收到消息receive
            data = conn.recv(1024)
            print(data)

            # 5. 回消息
            conn.send(data.upper())
        except ConnectionAbortedError:
            continue
        except ConnectionResetError:
            break

7.2 客户端

import socket

# 1. 创建符合TCp协议的手机
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 2. 拨号
client.connect(('127.0.0.1',8000))

while True:
    msg = input('please enter your msg')  # dir
    # 3. 发送消息
    client.send(msg.encode('utf8'))

    # 4. 接收消息
    data = client.recv(1024)
    print(data)

八、模拟ssh远程执行命令

在客户端处模拟ssh发送指令,服务端通过subprocess执行该命令,然后返回命令的结果

8.1 服务端

import socket
import subprocess

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.bind(('192.168.11.210', 8000))
server.listen(5)

print('start...')
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    while True:
        try:
            cmd = conn.recv(1024)  # dir
            print(cmd)

            # 帮你执行cmd命令,然后把执行结果保存到管道里
            pipeline = subprocess.Popen(cmd.decode('utf8'),
                                        shell=True,
                                        stderr=subprocess.PIPE,
                                        stdout=subprocess.PIPE)

            stderr = pipeline.stderr.read()
            stdout = pipeline.stdout.read()

            conn.send(stderr)
            conn.send(stdout)

        except ConnectionResetError:
            break

8.2 客户端

import socket

# 1. 创建符合TCp协议的手机
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

# 2. 拨号
client.connect(('192.168.11.210',8000))

while True:
    msg = input('please enter your msg')  # dir
    # 3. 发送消息
    client.send(msg.encode('utf8'))

    # 4. 接收消息
    data = client.recv(10)
    print(data.decode('gbk'))

九、粘包问题

两个数据非常小,然后间隔时间又短
数据太大,一次取不完,下一次还会取这个大数据

一十、解决粘包问题

在传数据之前,传一个数据的大小,数据的大小必须得定长

十一、基于UDP协议的socket套接字编程

UDP无连接

11.1 服务端

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8000))

print('start...')
while True:
    data, client_addr = server.recvfrom(1024)
    print(client_addr)
    print(data)
    server.sendto(data.upper(), client_addr)

11.2 客户端

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    msg = input('please enter your msg:')
    client.sendto(msg.encode('utf8'), ('127.0.0.1', 8000))

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

十二、基于socketserver实现并发的socket套接字编程

让服务端同时和多个客户端进行连接,以前我们写的是一个警局有五部电话只有一个人,现在写的是五部电话五个人

12.1 服务端

# 同一时刻有多个人在接听
import socketserver
import subprocess
import struct


class MyHandler(socketserver.BaseRequestHandler):
    # 通信循环
    def handle(self):

        while True:
            try:
                cmd = self.request.recv(1024)
                print(cmd)

                pipeline = subprocess.Popen(cmd.decode('utf8'),
                                            shell=True,
                                            stderr=subprocess.PIPE,
                                            stdout=subprocess.PIPE)

                stdout = pipeline.stdout.read()
                stderr = pipeline.stderr.read()

                count_len = len(stdout) + len(stderr)
                guding_bytes = struct.pack('i', count_len)

                self.request.send(guding_bytes)  # 4

                self.request.send(stderr + stdout)

            except ConnectionResetError:
                break


# 使用socketserver的连接循环(并发),但是使用了自己的通信循环
# myhandler = MyHandler()
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1', 8000), MyHandler, bind_and_activate=True)
    print('start...')
    server.serve_forever()

十三、网络编程的复习

1、什么是并发：

看起来是同时运行的，在多个任务里面来回切，切的时候保留上次的状态

2、生产者和消费者模型：

使用生产者和消费者模式能够解决绝大多数并发问题
1、什么是生产者与消费者模型？
    答：生产者消费者模型是通过一个容器来解决生产者和消费者的强耦合问题，
    生产者和消费者彼此之间不直接通信，而通过阻塞队列进行通信。所以生产者
    生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要
    数据，而是直接从阻塞队列里取。队列就相当于一个缓冲区，平衡了生产者和消费者
    的处理能力
    
2、为什么要有使用生产者和消费者模型？
    答：
        在多线程开发过程中，如果生产者生产者处理速度很快，而消费者处理速度很慢，
        那么生产者必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者
        处理能力大于生产者，那么消费者得等到生产者。就这样形成了相互等的形式。
        为了解决这个问题所以才引进了生产者和消费者模式

3、IPC（进程间的三种通信方式）：

方式一：队列（推荐使用）
    - 队列：队列类似于一条管道，元素先进先出
            需要注意的是：队列都是在内存中操作，进程退出，队列清空。另外，队列也是一种阻塞的状态
            
方式二：管道（不推荐）
    - 管道相当于队列，但是管道不自动加锁
    
方式三：共享数据（不推荐）
    - 共享数据也没有自动加锁的功能，所以还是推荐用队列。

4、实现并发有哪些手段？

1、开多进程：http://www.cnblogs.com/haiyan123/p/7445542.html
2、开多线程
3、进程池和线程池
    进程池和线程池是用来控制进程和线程的数目的，如果你开的进程特别多，那么你的机器就会很卡，
    所以我们得把进程控制好，用几个开几个，也不会太占用内存。
    p.close() #禁止往进程池内添加任务
4、协程gevent：单进程下实现并发

5、同步和异步：同步和异步就是提交任务的方式

 同步：提交完任务之后在原地等着
 异步：提交完任务之后就走了，不用等了，吧结果丢给了回调函数
 #注意：等不一定就是阻塞了（像是计算的时间比较长就得等，但不是阻塞），当遇到IO了才是阻塞

6、是不是所有的并发都更效率有关？

- 不是的，举个例子来说明一下
    举例：假如现在有三个任务，他们都是计算密集型的，没有遇到阻塞，他们串行这执行，
    如果你用并发，他们之间还得来回的切，在这切的过程中还会多产生切的时间，这倒不如用
    串行效率高呢。所以：当没有阻塞的时候，串行的效率比并发的效率高
- 那时候时候并发效率高呢？
    - 当遇到IO阻塞的时候，就让等的时间去执行其他的任务，这样才涉及到效率，

7、协程：一个任务运行完，切到另一个任务，单线程下实现并发

- 如果遇到IO才切，
- yield为协程提供了依据
协程参考链接：http://www.cnblogs.com/haiyan123/p/7461294.html

8、线程、协程、进程是不是真的存在呢？

线程、进程：是真的存在
协程：不存在，使人们意淫出来的

9、什么时候开多进程，什么时候开多线程？

IO密集型的，开多线程
计算密集型的，用多进程

10、线程和进程的区别？

1、创建线程比创建进程开销小（开一个进程，里面就有空间了，而线程在进程里面，就没必要在开一个空间了）
2、多线程一定是在一个进程里面开启的，共享进程里面的资源
3、线程启动的速度快
4、同一进程下的多个线程共享进程的资源，而多个进程之间内存空间是隔离的
5、线程可以跟它所在的进程之内 的线程通信
#注意：在wins下开进程，子进程不会拷贝父进程进程的
      #在linux下开进程，子进程会完全拷贝父进程的

11、GIL全局解释器锁

GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），
后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，
只能用户自定义加锁处理，即Lock
#如果不加锁：并发执行，速度快，数据不安全。

#加锁：串行执行，速度慢，数据安全。

12、锁的格式

import threading
mutex = threading.Lock()
mutex.aquire()
'''
对公共数据的操作
'''
mutex.release()

13、端口

http协议默认的端口是80
https（ssl）协议默认的端口是443，但是不用自己写，浏览器会默认加上

posted @ 2019-11-22 19:05 ABDM 阅读(151) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

登鹳雀楼

白日依山尽，黄河入海流。欲穷千里目，更上一层楼。

164 网络编程小结

一、网络编程小结

二、网络架构及其演变过程

2.1 单机架构

2.2 CS架构

2.3 BS架构

三、互联网和互联网的组成

3.1 教材版

3.2 科普版

四、大白话OSI七层协议

4.1 物理层

4.2 数据链路层

4.3 网络层

4.4 传输层

4.5 应用层

五、Socket抽象层

六、TCP协议的三次握手和四次挥手

6.1 三次握手建立连接

6.2 四次挥手断开连接

七、基于TCP协议的socket套接字编程

7.1 服务端

7.2 客户端

八、模拟ssh远程执行命令

8.1 服务端

8.2 客户端

九、粘包问题

一十、解决粘包问题

十一、基于UDP协议的socket套接字编程

11.1 服务端

11.2 客户端

十二、基于socketserver实现并发的socket套接字编程

12.1 服务端

十三、网络编程的复习

公告

登鹳雀楼

白日依山尽，黄河入海流。 欲穷千里目，更上一层楼。

164 网络编程小结

一、网络编程小结

二、网络架构及其演变过程

2.1 单机架构

2.2 CS架构

2.3 BS架构

三、互联网和互联网的组成

3.1 教材版

3.2 科普版

四、大白话OSI七层协议

4.1 物理层

4.2 数据链路层

4.3 网络层

4.4 传输层

4.5 应用层

五、Socket抽象层

六、TCP协议的三次握手和四次挥手

6.1 三次握手建立连接

6.2 四次挥手断开连接

七、基于TCP协议的socket套接字编程

7.1 服务端

7.2 客户端

八、模拟ssh远程执行命令

8.1 服务端

8.2 客户端

九、粘包问题

一十、解决粘包问题

十一、基于UDP协议的socket套接字编程

11.1 服务端

11.2 客户端

十二、基于socketserver实现并发的socket套接字编程

12.1 服务端

十三、网络编程的复习

公告

白日依山尽，黄河入海流。欲穷千里目，更上一层楼。