网络知识

CS架构与BS架构

Client<===========>Server
客户端软件send             服务端软件recv
操作系统                   操作系统
计算机硬件<====物理介质=====>计算机硬件
Browser<===========>Server

# 2、网络通信
网络存在的意义就是跨地域数据传输=》称之为通信
网络=物理链接介质+互联网通信协议
# 3、OSI七层协议
五层协议
    应用层
    传输层
    网络层
    数据链路层
    物理层
协议：规定数据的组织格式
    格式：头部+数据部分
    封包裹的过程：数据外加头
    拆包裹的过程：拆掉头获取数据

五层协议

#4、五层协议
计算机1：                            计算机2：
应用层                               应用层
传输层                               传输层
网络层                               网络层
数据链路层                            数据链路层
物理层  <===========交互机===========> 物理层
                                     0101010101010
（源mac地址，目标mac地址）（源ip地址，目标ip地址）数据
#4.1 物理层负责发送电信号
一组物理层数据称之为：位
单纯的电信号毫无意义，必须对其进行分组
#4.2 数据链路层：ethernet以太网协议
规定1：一组数据称之为一个数据帧
规定2：数据帧分成两部分=》头+数据
    头包含：源地址与目标地址，该地址是mac地址
    数据包含：包含的是网络层发过来的整体的内容
规定3：规定但凡接入互联网的主机必须有一块网卡，每块网卡在出厂时都烧制好一个全世界独一无二的地址，该地址称之为mac地址
注意：计算机通信基本靠吼，即以太网协议的工作方式是广播
（egon，血嫌弃）（帮我买包子）

网络层

#4.3 网络层：IP协议
要达到的目的：
划分广播域
每一个广播域但凡要接通外部，一定要有一个网关帮内部的计算机转发包到公网
网关与外界通信走的是路由协议
规定1：一组数据称之为一个数据包
规定2：数据帧分成两部分=》头+数据
    头包含：源地址与目标地址，该地址是IP地址
    数据包含的：传输层发过来的整体的内容
ipv4地址：
8bit.8bit.8bit.8bit
0.0.0.0
255.255.255.255
子网掩码：
8bit.8bit.8bit.8bit
255.255.255.0对应的二进制表达
11111111.11111111.11111111.00000000
一个合法的ipv4地址组成部分=ip地址/子网掩码地址
172.16.10.1/255.255.255.0
172.16.10.1/24
计算机1：
172.16.10.1：     10101100.00010000.00001010.000000001
255255.255.255.0: 11111111.11111111.11111111.000000000
172.16.10.0:      10101100.00010000.00001010.000000000
计算机2：
172.16.10.2：      10101100.00010000.00001010.000000010
255.255.255.255.0: 11111111.11111111.11111111.000000000
172.16.10.0:       10101100.00010000.00001010.000000000
计算机1：                            计算机2：
应用层                               应用层
传输层                               传输层
网络层                               网络层
数据链路层                           数据链路层
物理层  <=========二层交互机========> 物理层
                                     0101010101010
（源mac地址，xxxx）（源ip地址，目标ip地址）数据
（源mac地址，网关的mac地址）（172.16.10.10/24，101.100.200.11/10）数据
事先知道的是对方的ip地址
但是计算机的底层通信是基于ethernet以太网协议的mac地址通信
ARP：
所以必须能够将ip地址解析成mac地址
# 两台计算机在同一个局域网内
计算机1：172.16.10.10/24             直接              计算机2：172.16.10.11/24
ARP：
自己的ip，对方的ip
1、计算二者网络地址，如果一样，拿到计算机2的mac地址就可以了
2、发送广播包
发送端mac    FF:FF:FF:FF:FF:FF    172.16.10.10/24    172.16.10.11/24    数据
# 两台计算机不在同一个局域网内
计算机1：172.16.10.10/24                  网关           计算机2：101.100.200.11/10
ARP：
自己的ip，对方的ip
1、计算机二者网络地址，如果不一样，应该拿到网关的mac地址
2、发送广播包
发送端mac    FF:FF:FF:FF:FF:FF    172.16.10.10/24    172.16.10.1/24    数据
#4.3.1 总结******
ip地址+mac地址=》标识全世界范围内独一无二的一台计算机
或者：
ip地址=》标识全世界范围内独一无二的一台计算机

传输层

五层协议
计算机1：                            计算机2：
应用层                               应用层
socket                              socket
传输层               段               传输层
网络层               包               网络层
数据链路层            帧               数据链路层
物理层  <===========交互机===========> 物理层
客户端软件send             服务端软件recv
操作系统                   操作系统
计算机硬件<====物理介质=====>计算机硬件
ethernet头+ip头+tcp头+应用层的头+应用层数据
#一：传输层 tcp\udp=》基于端口
    端口范围0-65535，0-1023为系统占用端口
    ip+port=》标识全世界范围内独一无二的一个基于网络通信的应用程序
    基于tcp协议通信之前：必须建立一个双向通信的链接
    C-------------------->S
    C<--------------------S
    三次握手建立链接：
        建立链接是为了传数据做准备的，三次握手即可
    四次挥手断开链接
        断开链接时，由于链接内有数据传输，所以必须分四次断开
    tcp是可靠传输的
        发送数据必须等到对方确认后才算完成，才会将自己内存中的数据清理掉，否则重传
        ps：当服务端大量处于TIME_WAIT状态时意味着服务端正在经历高并发
    tcp协议的半连接池：
        backlog
        [链接请求1,链接请求2,链接请求3,链接请求5]
#二：应用层：
    可以自定义协议=》头部+数据部分
        自定义协议需要注意的问题：
        1、两大组成部分=头部+数据部分
            头部：放对数据的描述信息
                比如：数据要发给谁，数据的类型，数据的长度
            数据部分：想要发的数据
        2、头部的长度必须固定
            因为接收端要通过头部获取所接接收数据的详细信息
    http https ftp
www.163.com.
三：socket介绍
import socket

网络编程socket

基于tcp协议的套接字通信

服务端

import socket
# 1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # socket.AF_INET用于跨网络通信，socket.SOCK_STREAM流式协议=》tcp协议
# 2、绑定手机卡
phone.bind(('127.0.0.1',8081)) # 0-65535, 1024以前的都被系统保留使用
# 3、开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为:%s:%s' %('127.0.0.1',8080))
# 4、等待电话连接请求：拿到电话连接conn
conn,client_addr=phone.accept()  #获取连接对象及连接的ip地址
# print(conn)
print("客户端的ip和端口：",client_addr)
# 5、通信：收\发消息
data=conn.recv(1024) # 最大接收的数据量为1024Bytes，收到的是bytes类型
print("客户端发来的消息：",data.decode('utf-8'))
conn.send(data.upper())
# 6、关闭电话连接conn（必选的回收资源的操作)
conn.close()
# 7、关机（可选操作）
phone.close()

客户端

import socket
#1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # socket.AF_INET用于跨网络通信，socket.SOCK_STREAM流式协议=》tcp协议
#2、拨通服务端电话
phone.connect(('127.0.0.1',8081))
#3、通信
import time
time.sleep(10)
phone.send('hello egon 哈哈哈'.encode('utf-8'))
data=phone.recv(1024)
print(data.decode('utf-8'))
#4、关闭连接(必选的回收资源的操作)
phone.close()

服务端加上通信循环

服务端

import socket
# 1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议
# 2、绑定手机卡
phone.bind(('127.0.0.1',8083)) # 0-65535, 1024以前的都被系统保留使用
# 3、开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为:%s:%s' %('127.0.0.1',8080))
# 4、等待电话连接请求：拿到电话连接conn
conn,client_addr=phone.accept()
# 5、通信循环：收\发消息，只有一层while true
while True:
    try:
        data=conn.recv(1024) # 最大接收的数据量为1024Bytes，收到的是bytes类型
        if len(data) == 0:
            # 在unix系统洗，一旦data收到的是空
            # 意味着是一种异常的行为：客户度非法断开了链接
            break
        print("客户端发来的消息：",data.decode('utf-8'))
        conn.send(data.upper())
    except Exception:
        # 针对windows系统
        break
# 6、关闭电话连接conn（必选的回收资源的操作)
conn.close()
# 7、关机（可选操作）
phone.close()

客户端

import socket
#1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议
#2、拨通服务端电话
phone.connect(('127.0.0.1',8083))
#3、通信
while True:
    msg=input("输入要发送的消息>>>: ").strip() #msg=''
    if len(msg) == 0:continue
    phone.send(msg.encode('utf-8'))
    print('======?')
    data=phone.recv(1024)
    print(data.decode('utf-8'))
#4、关闭连接(必选的回收资源的操作)
phone.close()

服务端加上链接循环

# 服务端应该满足的特点：
# 1、一直提供服务
# 2、并发地提供服务
import socket
# 1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议
# 2、绑定手机卡
phone.bind(('127.0.0.1',8080)) # 0-65535, 1024以前的都被系统保留使用
# 3、开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为:%s:%s' %('127.0.0.1',8080))
# 4、等待电话连接请求：拿到电话连接conn
# 加上链接循环
while True:
    conn,client_addr=phone.accept()   #链接循环，整个处理消息的过程是单线程的。
    # 5、通信：收\发消息
    while True:
        try:
            data=conn.recv(1024) # 最大接收的数据量为1024Bytes，收到的是bytes类型
            if len(data) == 0:
                # 在unix系统洗，一旦data收到的是空
                # 意味着是一种异常的行为：客户度非法断开了链接
                break
            print("客户端发来的消息：",data.decode('utf-8'))
            conn.send(data.upper())
        except Exception:
            # 针对windows系统
            break
    # 6、关闭电话连接conn（必选的回收资源的操作)
    conn.close()
# 7、关机（可选操作）
phone.close()

基于udp协议的套接字通信

服务端

import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 数据报协议=》udp协议
server.bind(('127.0.0.1',8081))
while True:
    data,client_addr=server.recvfrom(1024)
    server.sendto(data.upper(),client_addr)
server.close()

客户端

import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
    msg=input('>>>: ').strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8081))
    res=client.recvfrom(1024)
    print(res)
client.close()

基于tcp协议远程执行命令

服务端

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加,针对windows系统实现端口重用
server.bind(('127.0.0.1',8082))
server.listen(5)
#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn,client_addr=server.accept()
    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)                            #当发送的字节数超过1024会产生粘包问题
            if len(cmd) == 0:break          #客户端发送cmd命令给服务端执行
            obj=subprocess.Popen(cmd.decode('utf-8'),  #开启子进程执行命令
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            print(len(stdout_res)+len(stderr_res))
            # conn.send(stdout_res+stderr_res) # ???
            conn.send(stdout_res)
            conn.send(stderr_res)
            # with open("1.mp4",mode='rb') as f:
            #     for line in f:
            #         conn.send(line)
        except Exception:
            break
    conn.close()

客户端

from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8082))
while True:
    cmd=input('请输入命令>>：').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    # 解决粘包问题思路：
    # 1、拿到数据的总大小total_size
    # 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
    # 3、直到recv_size=total_size，结束循环
    cmd_res=client.recv(1024) # 本次接收，最大接收1024Bytes
    print(cmd_res.decode('utf-8')) # 强调：windows系统用gbk
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留

udp协议没有粘包问题

服务端

import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
res1=server.recvfrom(2) # b"hello"
print(res1)
res2=server.recvfrom(3) # b"world"
print(res2)
server.close()

客户端

import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto(b'hello',('127.0.0.1',8080))
client.sendto(b'world',('127.0.0.1',8080))
client.close()

解决粘包问题

服务端

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1',8083))
server.listen(5)
#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn,client_addr=server.accept()
    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)
            if len(cmd) == 0:break
            obj=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            total_size=len(stdout_res)+len(stderr_res)
            # 1、先发头信息（固定长度的bytes）：对数据描述信息
            # int->固定长度的bytes
            header=struct.pack('i',total_size)   #将数据打包成整数类型二进制
            conn.send(header)  #发送总数据长度的二进制格式
            # 2、再发真实的数据
            conn.send(stdout_res)   #将执行结果发送给客户端
            conn.send(stderr_res)   #将执行错误信息发送给客户端
        except Exception:
            break
    conn.close()

客户端

import struct
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8083))
while True:
    cmd=input('请输入命令>>：').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    # 解决粘包问题思路：
    # 一、先收固定长度的头：解析出数据的描述信息，包括数据的总大小total_size
    header=client.recv(4)
    total_size=struct.unpack('i',header)[0]    #i代表interger整数类型
    # 二、根据解析出的描述信息，接收真实的数据
    # 2、recv_size=0,循环接收，每接收一次，recv_size+=接收的长度
    # 3、直到recv_size=total_size，结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data=client.recv(1024)
        recv_size+=len(recv_data)
        print(recv_data.decode('utf-8'),end='')
    else:
        print()
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留

解决粘包问题（终极版）

struct.pack

res=struct.pack(‘i’,999999999) #对999999999以内数字封包都是4个字节长度。

import json
import struct
header_dic={
                "filename":"a.txt",
                "total_size":12312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312311231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231231231231212222222222222222222222222312312312312312122222222222222222222222223123123123123121222222222222222222222222231231232312122222222222222222222222223123123,
                "md5":"123123xi12ix12",
                "asf":"123123xi12ix12",
                "asf1":"123123xi12ix12",
                "asf2":"123123xi12ix12",
                "asf3":"123123xi12ix12",
}
json_str=json.dumps(header_dic)
json_str_bytes=json_str.encode('utf-8')
print(len(json_str_bytes))
res=struct.pack('i',999999999)  #对999999999以内数字封包都是4个字节长度。
print(res,len(res))
res=struct.pack('i',len(json_str_bytes))

服务端

# 服务端应该满足两个特点：
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
import struct
import json
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1',8083))
server.listen(5)
#  服务端应该做两件事
# 第一件事：循环地从板连接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn,client_addr=server.accept()
    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)
            if len(cmd) == 0:break
            obj=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            total_size=len(stdout_res)+len(stderr_res)
            # 1、制作头
            header_dic={
                "filename":"a.txt",
                "total_size":total_size,
                "md5":"123123xi12ix12"
            }
            json_str = json.dumps(header_dic)
            json_str_bytes = json_str.encode('utf-8')
            # 2、先把头的长度发过去
            x=struct.pack('i',len(json_str_bytes))
            conn.send(x)
            # 3、发头信息
            conn.send(json_str_bytes)
            # 4、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)
        except Exception:
            break
    conn.close()

客户端

import struct
import json
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8083))
while True:
    cmd=input('请输入命令>>：').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    # 接收端
    # 1、先手4个字节，从中提取接下来要收的头的长度
    x=client.recv(4)
    header_len=struct.unpack('i',x)[0]
    # 2、接收头，并解析
    json_str_bytes=client.recv(header_len)
    json_str=json_str_bytes.decode('utf-8')
    header_dic=json.loads(json_str)
    print(header_dic)
    total_size=header_dic["total_size"]
    # 3、接收真实的数据
    recv_size = 0
    while recv_size < total_size:
        recv_data=client.recv(1024)
        recv_size+=len(recv_data)
        print(recv_data.decode('utf-8'),end='')
    else:
        print()
# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残留，就会下一次结果混淆在一起
# 解决的核心法门就是：每次都收干净，不要任何残留

socketserver模块

基于tcp协议的使用

服务端、支持并发

import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        # 如果tcp协议，self.request=>conn
        print(self.client_address)
        while True:
            try:
                msg = self.request.recv(1024)
                if len(msg) == 0: break
                self.request.send(msg.upper())
            except Exception:
                break
        self.request.close()
#  服务端应该做两件事
# 第一件事：循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
# 实例化得到一个tcp连接的对象，Threading意思是，只要来了请求，它自动开一个线程来处理并进行交互
# 第一个参数是绑定的地址，第二个参数的传一个类
s=socketserver.ThreadingTCPServer(('127.0.0.1',8889),MyRequestHandle)  
s.serve_forever()
# 等同于
# while True:
#     conn,client_addr=server.accept()
#     启动一个线程(conn,client_addr)
# 第二件事：拿到链接对象，与其进行通信循环===>handle

客户端

from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8889))
while True:
    msg=input('请输入命令>>：').strip()
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8'))
    res=client.recv(1024)
    print(res.decode('utf-8'))

基于udp协议

服务端

import socketserver
class MyRequestHanlde(socketserver.BaseRequestHandler):
    def handle(self):
        client_data=self.request[0]
        server=self.request[1]
        client_address=self.client_address
        print('客户端发来的数据%s' %client_data)
        server.sendto(client_data.upper(),client_address)
s=socketserver.ThreadingUDPServer(("127.0.0.1",8888),MyRequestHanlde)
s.serve_forever()
# 相当于:只负责循环地收
# while True:
#     data,client_addr=server.recvfrom(1024)
#     启动一个线程处理后续的事情(data,client_addr)

客户端

import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
    msg=input('>>>: ').strip()
    client.sendto(msg.encode('utf-8'),('115.29.65.16',8888))
    res=client.recvfrom(1024)
    print(res)
client.close()

进程

同步异步、阻塞与非阻塞

切换(CPU)分为两种情况
    1.当一个程序遇到IO操作的时候，操作系统会剥夺该程序的CPU执行权限
        作用:提高了CPU的利用率 并且也不影响程序的执行效率
    2.当一个程序长时间占用CPU的时候，操作吸引也会剥夺该程序的CPU执行权限
        弊端:降低了程序的执行效率(原本时间+切换时间)
同步和异步
"""描述的是任务的提交方式"""
同步:任务提交之后，原地等待任务的返回结果，等待的过程中不做任何事(干等)
      程序层面上表现出来的感觉就是卡住了
异步:任务提交之后，不原地等待任务的返回结果，直接去做其他事情
      我提交的任务结果如何获取？
    任务的返回结果会有一个异步回调机制自动处理
阻塞非阻塞
"""描述的程序的运行状态"""
阻塞:阻塞态
非阻塞:就绪态、运行态
理想状态:我们应该让我们的写的代码永远处于就绪态和运行态之间切换

同步代码

import time
def func():
    time.sleep(3)
    print('hello world')
if __name__ == '__main__':
    res = func()  # 同步调用
    print('hahaha')

开启进程的二种方式

第一种直接使用multiprocessing的process创建对象

第二种使用类继承process类，实现run方法

# 第一种（直接使用）
from multiprocessing import Process
import time
def task(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is over'%name)
if __name__ == '__main__':
    # 1 创建一个对象
    p = Process(target=task, args=('jason',))   #传入需要执行的函数，及函数参数
    # 容器类型哪怕里面只有1个元素 建议要用逗号隔开
    # 2 开启进程
    p.start()  # 告诉操作系统帮你创建一个进程  异步
    print('主')
"""
windows操作系统下 创建进程一定要在main内创建
因为windows下创建进程类似于模块导入的方式
会从上往下依次执行代码
linux中则是直接将代码完整的拷贝一份
"""
# 第二种方式 类的继承
from multiprocessing import Process
import time
class MyProcess(Process):    #继承process方法
    def run(self):           #需要实现run方法
        print('hello bf girl')
        time.sleep(1)
        print('get out!')
if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print('主')

join方法

start方法：开启p进程

join方法：阻塞创建的p进程运行，主进程等待子进程p运行结束后再继续往后执行。

from multiprocessing import Process
import time
def task(name, n):
    print('%s is running'%name)
    time.sleep(n)
    print('%s is over'%name)
if __name__ == '__main__':
    # p1 = Process(target=task, args=('jason', 1))
    # p2 = Process(target=task, args=('egon', 2))
    # p3 = Process(target=task, args=('tank', 3))
    # start_time = time.time()
    # p1.start()
    # p2.start()
    # p3.start()  # 仅仅是告诉操作系统要创建进程
    # # time.sleep(50000000000000000000)
    # # p.join()  # 主进程等待子进程p运行结束之后再继续往后执行
    # p1.join()
    # p2.join()
    # p3.join()
    start_time = time.time()
    p_list = []
    for i in range(1, 4):
        p = Process(target=task, args=('子进程%s'%i, i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('主', time.time() - start_time)

进程间数据隔离

进程间数据并不共享

创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去
一个进程对应在内存中就是一块独立的内存空间
多个进程对应在内存中就是多块独立的内存空间
进程与进程之间数据默认情况下是无法直接交互,如果想交互可以借助于第三方工具、模块

from multiprocessing import Process
money = 100
def task():
    global money  # 局部修改全局
    money = 666
    print('子',money)
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print(money)
打印结果:
    子 666
    100

进程对象及其他方法

os.getppid() 查看当前父进程的进程号

os.getpid() 查看当前进程号

current_process().pid # 查看当前进程的进程号

p.terminate() # 杀死当前进程

        是告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快

p.is_alive() # 判断当前进程是否存活

from multiprocessing import Process, current_process
import time
import os
def task():
    # print('%s is running'%current_process().pid)  # 查看当前进程的进程号
    print('%s is running'%os.getpid())  # 查看当前进程的进程号
    # print('子进程的主进程号%s'%os.getppid())  # 查看当前进程的进程号
    time.sleep(30)
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.terminate()  # 杀死当前进程
    # 是告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快
    time.sleep(0.1)
    print(p.is_alive())  # 判断当前进程是否存活
    """
    一般情况下我们会默认将
    存储布尔值的变量名
    和返回的结果是布尔值的方法名
    都起成以is_开头
    """
    print('主')
    # print('主',current_process().pid)
    # print('主',os.getpid())
    # print('主主',os.getppid())  # 获取父进程的pid号

僵尸与孤儿进程

# 僵尸进程
"""
死了但是没有死透
当你开设了子进程之后 该进程死后不会立刻释放占用的进程号
因为我要让父进程能够查看到它开设的子进程的一些基本信息 占用的pid号 运行时间。。。
所有的进程都会步入僵尸进程
    父进程不死并且在无限制的创建子进程并且子进程也不结束
    回收子进程占用的pid号
        父进程等待子进程运行结束
        父进程调用join方法
"""
# 孤儿进程
"""
子进程存活，父进程意外死亡
操作系统会开设一个“儿童福利院”专门管理孤儿进程回收相关资源
"""

from multiprocessing import Process
import time
def run():
    print('hello world')
    time.sleep(3)
    print('get out')
if __name__ == '__main__':
    p = Process(target=run)
    p.start()
    print('主')

守护进程

1.1、什么是守护进程？

**1、*_守护进程会在主进程代码运行结束的情况下，立即挂掉。*_**
**2、守护进程本身就是一个子进程。**
**3、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，**

p.daemon = True # 将进程p设置成守护进程 这一句一定要放在start方法上面才有效否则会直接报错
p.start()

from multiprocessing import Process
import time
def task(name):
    print('%s总管正在活着'% name)
    time.sleep(3)
    print('%s总管正在死亡' % name)
if __name__ == '__main__':
    p = Process(target=task,args=('egon',))
    # p = Process(target=task,kwargs={'name':'egon'})
    p.daemon = True  # 将进程p设置成守护进程  这一句一定要放在start方法上面才有效否则会直接报错
    p.start()
    print('皇帝jason寿终正寝')

互斥锁

from multiprocessing import Process, Lock

多个进程操作同一份数据的时候，会出现数据错乱的问题

针对上述问题，解决方式就是加锁处理:将并发变成串行，牺牲效率但是保证了数据的安全

mutex = Lock()

mutex.acquire() #进程抢锁

干活，操作同一个数据

mutex.release() #进程释放锁

注意：
    1.锁不要轻易的使用，容易造成死锁现象(我们写代码一般不会用到，都是内部封装好的)
    2.锁只在处理数据的部分加来保证数据安全(只在争抢数据的环节加锁处理即可)

from multiprocessing import Process, Lock
import json
import time
import random
# 查票
def search(i):
    # 文件操作读取票数
    with open('data', 'r', encoding='utf8') as f:
        dic = json.load(f)
    print('用户%s查询余票：%s'%(i, dic.get('ticket_num')))
    # 字典取值不要用[]的形式 推荐使用get  你写的代码打死都不能报错！！！
# 买票  1.先查 2.再买
def buy(i):
    # 先查票
    with open('data', 'r', encoding='utf8') as f:
        dic = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1,3))
    # 判断当前是否有票
    if dic.get('ticket_num') > 0:
        # 修改数据库 买票
        dic['ticket_num'] -= 1
        # 写入数据库
        with open('data', 'w', encoding='utf8') as f:
            json.dump(dic,f)
        print('用户%s买票成功'%i)
    else:
        print('用户%s买票失败'%i)
# 整合上面两个函数
def run(i, mutex):
    search(i)
    # 给买票环节加锁处理
    # 抢锁
    mutex.acquire()
    buy(i)
    # 释放锁
    mutex.release()
if __name__ == '__main__':
    # 在主进程中生成一把锁 让所有的子进程抢 谁先抢到谁先买票
    mutex = Lock()
    for i in range(1,11):
        p = Process(target=run, args=(i, mutex))
        p.start()

进程队列 Queue

队列:先进先出
堆栈:先进后出

from multiprocessing import Queue
q = Queue()  # 括号内可以放数字来限制队列的大小
q.put()              # 放数据  当队列满了再放 阻塞
q.get()          # 取数据  当队列空了再取 阻塞
q.full()          # 判断队列是否满了
q.empty()          # 判断队列是否空了
q.get_nowait()  # 取数据的时候如果没有数据直接报错
q.get(timeout=5)  # 取数据的时候如果没有数据等5s还没有则直接报错

try:
    v6 = q.get(timeout=3)
    print(v6)
except Exception as e:
    print('一滴都没有了!')

from multiprocessing import Queue
# 创建一个队列
q = Queue(5)  # 括号内可以传数字 标示生成的队列最大可以同时存放的数据量
# 往队列中存数据
q.put(111)
q.put(222)
q.put(333)
# print(q.full())  # 判断当前队列是否满了
# print(q.empty())  # 判断当前队列是否空了
q.put(444)
q.put(555)
# print(q.full())  # 判断当前队列是否满了
# q.put(666)  # 当队列数据放满了之后 如果还有数据要放程序会阻塞 直到有位置让出来 不会报错
"""
存取数据 存是为了更好的取
千方百计的存、简单快捷的取
同在一个屋檐下
差距为何那么大
"""
# 去队列中取数据
v1 = q.get()
v2 = q.get()
v3 = q.get()
v4 = q.get()
v5 = q.get()
# print(q.empty())
# V6 = q.get_nowait()  # 没有数据直接报错queue.Empty
# v6 = q.get(timeout=3)  # 没有数据之后原地等待三秒之后再报错  queue.Empty
try:
    v6 = q.get(timeout=3)
    print(v6)
except Exception as e:
    print('一滴都没有了!')
# # v6 = q.get()  # 队列中如果已经没有数据的话 get方法会原地阻塞
# print(v1, v2, v3, v4, v5, v6)
"""
q.full()
q.empty()
q.get_nowait()
在多进程的情况下是不精确
"""

IPC机制-进程+队列

进程间通信

"""
进程之间是无法直接进行数据交互的，但是可以通过队列或者管道实现数据交互
   管道:
   队列:管道+锁
本地测试的时候才可能会用到Queue，实际生产用的都是别人封装好的功能非常强大的工具
redis
kafka
RQ
"""

from multiprocessing import Queue, Process
"""
研究思路
    1.主进程跟子进程借助于队列通信
    2.子进程跟子进程借助于队列通信
"""
def producer(q):
    q.put('我是23号技师 很高兴为您服务')
def consumer(q):
    print(q.get())
if __name__ == '__main__':
    q = Queue()  #创建一个队列
    p = Process(target=producer,args=(q,))   #将q队列传入，调用put方法
    p1 = Process(target=consumer,args=(q,))  #将q队列传入，调用get方法
    p.start()
    p1.start()

生产消费者模型

"""
生产者:生产/制造东西的
消费者:消费/处理东西的
该模型除了上述两个之外还需要一个媒介
    生活中的例子做包子的将包子做好后放在蒸笼(媒介)里面，买包子的取蒸笼里面拿
    厨师做菜做完之后用盘子装着给你消费者端过去
    生产者和消费者之间不是直接做交互的，而是借助于媒介做交互
生产者(做包子的) + 消息队列(蒸笼) + 消费者(吃包子的)
"""

from multiprocessing import Process, Queue, JoinableQueue
import time
import random
def producer(name,food,q):
    for i in range(5):
        data = '%s生产了%s%s'%(name,food,i)
        # 模拟延迟
        time.sleep(random.randint(1,3))
        print(data)
        # 将数据放入 队列中
        q.put(data)
def consumer(name,q):
    # 消费者胃口很大 光盘行动
    while True:
        food = q.get()  # 没有数据就会卡住
        # 判断当前是否有结束的标识
        # if food is None:break
        time.sleep(random.randint(1,3))
        print('%s吃了%s'%(name,food))
        q.task_done()  # 告诉队列你已经从里面取出了一个数据并且处理完毕了
if __name__ == '__main__':
    # q = Queue()
    q = JoinableQueue()  #每当你往该队列中存入数据的时候 内部会有一个计数器+1
    p1 = Process(target=producer,args=('大厨egon','包子',q))
    p2 = Process(target=producer,args=('马叉虫tank','泔水',q))
        #消费者
    c1 = Process(target=consumer,args=('春哥',q))
    c2 = Process(target=consumer,args=('新哥',q))
    p1.start()
    p2.start()
    # 将消费者设置成守护进程
    c1.daemon = True
    c2.daemon = True
    c1.start()   #开始消费
    c2.start()    
    p1.join()
    p2.join()
    # 等待生产者生产完毕之后 往队列中添加特定的结束符号
    # q.put(None)  # 肯定在所有生产者生产的数据的末尾
    q.join()  # 等待队列中所有的数据被取完再执行往下执行代码
    """
    JoinableQueue 每当你往该队列中存入数据的时候 内部会有一个计数器+1
    没当你调用task_done的时候 计数器-1
    q.join() 当计数器为0的时候 才往后运行
    """
    # 只要q.join执行完毕 说明消费者已经处理完数据了  消费者就没有存在的必要了

线程

致命三问

• 什么是线程 ```css “”” 进程:资源单位 线程:执行单位

将操作系统比喻成一个大的工厂 那么进程就相当于工厂里面的车间 而线程就是车间里面的流水线

每一个进程肯定自带一个线程

再次总结: 进程:资源单位(起一个进程仅仅只是在内存空间中开辟一块独立的空间) 线程:执行单位(真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程索要)

进程和线程都是虚拟单位，只是为了我们更加方便的描述问题 “””

- 
为何要有线程
```python
"""
开设进程
    1.申请内存空间    耗资源
    2.“拷贝代码”   耗资源
开线程
    一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间操作
总结:
    开设线程的开销要远远的小于进程的开销
    同一个进程下的多个线程数据是共享的!!!
"""
我们要开发一款文本编辑器
    获取用户输入的功能
  实时展示到屏幕的功能
  自动保存到硬盘的功能
针对上面这三个功能，开设进程还是线程合适？？？
    开三个线程处理上面的三个功能更加的合理

• 如何使用

• 线程理论

"""
进程:资源单位
线程:执行单位
线程才是真正干活的人，干活的过程中需要的资源由线程所在的进程提供
每一个进程肯定都自带一个线程 
同一个进程内可以创建多个线程
"""
"""
开进程
    申请内存空间  
    ”拷贝代码“
    消耗资源较大
开线程
    同一个进程内创建多个线程 无需上述两部操作，消耗资源相对较小
智商
情商
搜商
"""

今日内容概要

• 开启线程的两种方式
• TCP服务端实现并发的效果
• 线程对象的join方法
• 线程间数据共享
• 线程对象属性及其他方法
• 守护线程
• 线程互斥锁
• GIL全局解释器锁
• 多进程与多线程的实际应用场景

开启线程的两种方式

与开启进程方式类似，直接使用thread创建或者类继承

# from multiprocessing import Process
# from threading import Thread
# import time
#
#
# def task(name):
#     print('%s is running'%name)
#     time.sleep(1)
#     print('%s is over'%name)
#
#
# # 开启线程不需要在main下面执行代码 直接书写就可以
# # 但是我们还是习惯性的将启动命令写在main下面
# t = Thread(target=task,args=('egon',))
# # p = Process(target=task,args=('jason',))
# # p.start()
# t.start()  # 创建线程的开销非常小 几乎是代码一执行线程就已经创建了
# print('主')
from threading import Thread
import time
class MyThead(Thread):
    def __init__(self, name):
        """针对刷个下划线开头双下滑线结尾(__init__)的方法 统一读成 双下init"""
        # 重写了别人的方法 又不知道别人的方法里有啥 你就调用父类的方法
        super().__init__()
        self.name = name
    def run(self):
        print('%s is running'%self.name)
        time.sleep(1)
        print('egon DSB')
if __name__ == '__main__':
    t = MyThead('egon')
    t.start()
    print('主')

TCP服务端实现并发

import socket
from threading import Thread
from multiprocessing import Process
"""
服务端
    1.要有固定的IP和PORT
    2.24小时不间断提供服务
    3.能够支持并发
从现在开始要养成一个看源码的习惯
我们前期要立志称为拷贝忍者 卡卡西 不需要有任何的创新
等你拷贝到一定程度了 就可以开发自己的思想了
"""
server =socket.socket()  # 括号内不加参数默认就是TCP协议
server.bind(('127.0.0.1',8080))
server.listen(5)
# 将服务的代码单独封装成一个函数
def talk(conn):
    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            # 针对mac linux 客户端断开链接后
            if len(data) == 0: break
            print(data.decode('utf-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()
# 链接循环
while True:
    conn, addr = server.accept()  # 接客
    # 叫其他人来服务客户
    # t = Thread(target=talk,args=(conn,))
    t = Process(target=talk,args=(conn,))
    t.start()
"""客户端"""
import socket
client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
    client.send(b'hello world')
    data = client.recv(1024)
    print(data.decode('utf-8'))

线程对象的join方法

from threading import Thread
import time
def task(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is over'%name)
if __name__ == '__main__':
    t = Thread(target=task,args=('egon',))
    t.start()
    t.join()  # 主线程等待子线程运行结束再执行
    print('主')

同一个进程下的多个线程数据是共享的

from threading import Thread
import time
money = 100
def task():
    global money
    money = 666
    print(money)
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    t.join()
    print(money)

线程对象属性及其他方法

print('主',active_count())  # 统计当前正在活跃的线程数
print('主',os.getpid())
print('主',current_thread().name)  # 获取线程名字

from threading import Thread, active_count, current_thread
import os,time
def task(n):
    # print('hello world',os.getpid())
    print('hello world',current_thread().name)
    time.sleep(n)
if __name__ == '__main__':
    t = Thread(target=task,args=(1,))
    t1 = Thread(target=task,args=(2,))
    t.start()
    t1.start()
    t.join()
    print('主',active_count())  # 统计当前正在活跃的线程数
    # print('主',os.getpid())
    # print('主',current_thread().name)  # 获取线程名字