day35

 套子介绍：

1.互联网=物理连接介质+互联网协议  

   应用层

   传输层

   网络层

   数据连接层

   物理层

 结论：

       ip+port能够标识全世界范围内独一无二的一个应用软件

2.TCP的三次握手，四次挥手

    TCP vs UDP

3.基于tcp协议通讯的套接字

   tcp粘包问题以及解决方案

4.基于udp协议通讯的套接字

1. TCP半连接池原理

  什么情况下会进入半连接池 来不及处理accep 或者客户端单方面终止连接

2.UDP 通讯

   写代码的区别 对比TCP

      没有listen

      没有accept

      发送使用sendto 需要指定接收方的地址

      recvfrom 缓冲区大小最大建议512 需要和发送方一样大

3.UDP聊天 input会阻塞 导致recv无法立即获取数据

4.TCP 和 UTP通讯的流程

  需要先绑定端口

  TCP从操作系统缓存取出数据 发送给服务器 必须接收服务器返回的确认包

        更加安全

  udp 从操作系统缓存取出数据 发送给服务器 不需要确认 数据可能

    更加高效

5.什么是进程

  一个正在运行的程序称之为进程

         是一种抽象概念 表示一个执行某件事情的过程

    进程的概念 起源于程序系统

   第一代计算机 程序是固定 无法修改 某种计算机只能干某种活

   第二代批处理系统 需要人工参与 将程序赞成一批 统一执行

       串行执行 提高计算机的利用率 但是调式麻烦

   第三代计算机 为了计算更好利用计算机资源，产生了多道技术：*****

    1.空间复用

       内存分割为多个区域 每个区域存储不同的应用程序

     2.时间的复用

       1.当一个程序遇到了I/O操作时 会切换到其他程序（切换前需要保存当前运行状态以便恢复执行）

   提高效率

       2.当你的应用程序执行时间过长 操作系统会强制性切走 以保证其他程序的正常运行 当然因为cpu速度快 用户感觉不到

           降低效率

        3.有一个优先级更高的任务需要处理 此时也会切换走

          降低了效率

         我们编写程序时 只能减少i/o操作

 总的来说 有了多道技术之后 操作系统可以运行多个程序  这种情况称之为并发但是本质还是好的这些程序还是 一个一个排队执行

并发：

  在同一个时间段内 发送多个事情

并行：

  在同一时刻 同时进行多个事情

串行  许多任务排队执行

    第一个任务没执行完 第二个只能等待

    此时不叫阻塞 因为CPU执行权还在手里 依然在执行你的代码

    第一个任务做不下去i/o操作 此时就是阻塞 因为cpu被分配给其他进程

总结一下：只要还有cup的执行 权 就不叫阻塞

  非阻塞

   同步 和 异步

        print

("asasasasasasasasasasasadfsdfsdfsdfsfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")

       print("over")

        input(">>>>:")

  思考：多个处理器 能不能真正的并行？
      可以 每个核可以单独负责一个任务 这些任务可以同时进行

print("start")

 我不让当进程做取读这个事情 而是让一个别的进程去读 对于当前进程 就不会再阻塞

with open("xxxx")as f

    f.read()

print("over")

这是主程序

from multiprocessing import Process
import  time,os
def task(name):
   print("process running")
    time.sleep(3)
    print("process stop")

if __name__ == '__main__':
为毛创建进程
1.创建一个进程对象 需要传入你要做的任务 就是一个函数对象
   p = Process(target=task)
2.启动它
    p.start()

当你完成的任务需要参数时
def task(name):
    print(name," running")
    time.sleep(3)
    print(name," stop")
print(__name__)

windows 开启子进程 必须放到if中     只要你的开启子进程的代码处于全局 范围 你就应该放到if判断中
if __name__ == '__main__':
    为毛创建进程 为了帮父进程做事情
    1.创建一个进程对象 需要传入你要做的任务 就是一个函数对象
    p = Process(target=task,kwargs={"name":"jerry"})
    2.启动它
    p.start()
    print(id(p))
    print("我是主程序我的pid:%s 我的父进程是:%s" % (os.getpid(),os.getppid()))
    print("我有一个儿子是 %s" % p.pid)

进行理论：

 进程和程序的区别

程序是什么？
  本质就是一堆文件代码！

  一个程序真正被操作系统取读并执行 就变成了程序

一个程序只能有一个进程吗？
   可以 启动一次就产生一个进程 当然可以用代码控制是否允许多进程

启动进程的方式

   1.系统初始化 会产生一个根进程

    2.用户的交互请求 鼠标双击某一个程序

    3.在一个进程中 发起了系统调用启动了另一个进程

     4.批处理作业开始 某一些专用计算机可能还在使用

不同操作系统创建进程方式不同

    unix<centos mac linux

        完全拷贝父进程的所有数据 子进程可以访问父进程的数据吗？不可以 但是可以访问拷贝过来数据副本

    windows

         创建子进程 加载父进程中所有可执行的文件

4.主进程与进程的这些顺序：

from multiprocessing import Process
import  time,os
def task(name):
    print("process running")
    time.sleep(3)
    print("process stop")

if __name__ == '__main__':
为毛创建进程
1.创建一个进程对象 需要传入你要做的任务 就是一个函数对象
     p = Process(target=task)
 2.启动它
     p.start()

 当你完成的任务需要参数时
def task(name):
    print(name," running")
    time.sleep(3)
    print(name," stop")
print(__name__)

 windows 开启子进程 必须放到if中     只要你的开启子进程的代码处于全局 范围 你就应该放到if判断中
if __name__ == '__main__':
     为毛创建进程 为了帮父进程做事情
     1.创建一个进程对象 需要传入你要做的任务 就是一个函数对象
    p = Process(target=task,kwargs={"name":"jerry"})
     2.启动它
    p.start()
    print(id(p))
    print("我是主程序我的pid:%s 我的父进程是:%s" % (os.getpid(),os.getppid()))
    print("我有一个儿子是 %s" % p.pid)

5.父进程等待子进程结束：

from multiprocessing import  Process
import time

def task(name):
    print("%s start" % name)
    time.sleep(3)

    print("%s stop" % name)

if __name__ == '__main__':
    p = Process(target=task,args=("jerry",))
    p.start()
    p.join(3)   #父进程必须等到子进程完成后才能继续执行  可设置等待超时时间
    print("我是主进程!!!")




def task(i):
    print("%s start" % i)
 time.sleep(2)
print("%s stop" % i)

if __name__ == '__main__':
    for i in range(1,11):
        p = Process(target=task,args=(i,))
        p.start()
    print("主进程!!!!")

我们的代码只负责 通知操作系统创建进程  创建完就继续其他代码
但是操作系统什么时候创建完成 什么时候执行我们无法预知无法控制
def task(i):
    print("%s start" % i)
    time.sleep(2)
    print("%s stop" % i)

if __name__ == '__main__':
    start_time = time.time()
    ps = []
    for i in range(1,3):
        p = Process(target=task,args=(i,))
        p.start()
        ps.append(p)
         主进程等子进程结束

6.开启了子进程的方式2：

from multiprocessing import Process


class MyProcess(Process):
当进程被执行时 其实执行的就是run函数
    def run(self):
        print("这是 run被执行了!")



def ttt():
    print("11111")
if __name__ == '__main__':
    mp = MyProcess()
    mp.start()

    p = Process(target=ttt)
    p.start()

7.进程对象常用属性：

from multiprocessing import  Process
import  time


def task(name):
    print("start",name)
    time.sleep(5)
    print("stop",name)

if __name__ == '__main__':
   p = Process(target=task,args=("jerry",),name="jerrr process-1")
   p.start()
   p.join() # 让父进程等待子进程结束  让父进程让出了CPU执行权
   print(p.name)
   print(p.pid) # 获取这个进程的id
   p.terminate() # 结束子进程
   print(p.is_alive()) # 进程是否还存活

   p这个进程的父进程 是7.进程对象常用属性.py这个进程
   import os
   print(os.getpid()) # 当前自己进程的id
   print(os.getppid())# pycharm的进程id

  父进程如何获取子进程中数据  跨进程通讯

小结：

1.多道技术

   空间复用

   时间复用

2.Python如何使用多进程

    1.直接创建process对象 同时传入要做的事情是一个函数

     2.创建一个类 继承自process 把要做的任务放在run方法中

3.父进程与子进程间的执行顺序*****

4.常用属性

    start 开启进程

    join 父进程等待子进程

    name 进程名称

    is_alive是否存活

    terminate 终止进程

    pid 获取进程id

僵尸进程与孤儿进程：

一个进程任务执行完就死亡了 但是操作系统不会立即将其清理 为的是 开启这个子进程的父进程可以访问到这个子进程的信息

这样的 任务完成的 但是没有被操作系统清理的进程称之为僵尸进程 越少越好

孤儿进程 无害！！！

   没有爹的称之为孤儿

   一个父进程已经死亡 然而他的子孙进程 还在执行着 这时候 操作系统会接管这些孤儿进程

   为什么要加if_name_看下边图片：

这是个进程：
import time

time.sleep(50)