网络并发3

UDP代码编写

        import socket
        udp_sk = socket.socket(type=socket.SOCK_DGRAM)  # UDP协议
        udp_sk.bind(('127.0.0.1',9000))  # 绑定地址
        msg,addr = udp_sk.recvfrom(1024)
        udp_sk.sendto(b'hi',addr)             
        udp_sk.close() 


        import socket
        ip_port=('127.0.0.1',9000)
        udp_sk=socket.socket(type=socket.SOCK_DGRAM)
        udp_sk.sendto(b'hello',ip_port)
        back_msg,addr=udp_sk.recvfrom(1024)
        print(back_msg.decode('utf-8'),addr)

        """
        时间服务器的实现原理
            1.内部小电容供电
            2.远程时间同步
        """

操作系统发展史

        """学习并发编程其实就是在学习操作系统的发展史(底层逻辑)"""
        1.穿孔卡片时代
            CPU的利用率极低
        2.联机批处理系统
            将多个程序员的程序一次性录入磁带中 之后交由输入机输入并由CPU执行
        3.脱机批处理系统
            现代计算机的雏形(远程输入 高速磁带 主机)

多道技术

        # 前提:单核CPU
            多道技术
                切换+保存状态
        """
        CPU工作机制
            1.当某个程序进入IO状态的时候 操作系统会自动剥夺该程序的CPU执行权限
            2.当某个程序长时间占用CPU的时候 操作系统也会剥夺该程序的CPU执行权限
        """

        并行与并发(******)
            并行:多个程序同时执行
            并发:多个程序只要看起来像同时运行即可
        # 问:单核CPU能否实现并行
            肯定不能，但是可以实现并发
        # 问:12306可以同一时间支持几个亿的用户买票 问是并行还是并发
            肯定是并发(高并发)		
        星轨:微博能够支持八个星轨

进程理论

        # 进程与程序的区别
            程序:一堆代码(死的)
            进程:正在运行的程序(活的)

        # 单核情况下的进程调度
            进程调度算法演变
                1.FCFS	先来先服务
                    对短作业不友好
                2.短作业优先调度算法
                    对长作业不友好
                3.时间片轮转法+多级反馈队列
                    先分配给新的多个进程相同的时间片
                    之后根据进程消耗的时间片多少分类别......

        # 进程三状态图(******)
            就绪态 运行态 阻塞态
                进程要想进入运行态必须先经过就绪态

        # 同步与异步(******)
            '''用于描述任务的提交方式'''
            同步:提交完任务之后原地等待任务的返回结果 期间不做任何事 （傻等）
            异步:提交完任务之后不原地等待任务的返回结果 直接去做其他事 结果由反馈机制自动提醒 （合理安排）

        # 阻塞与非阻塞(******)
            '''用于描述任务的执行状态'''
            阻塞:阻塞态
            非阻塞:就绪态 运行态

创建进程

        # 代码层面创建进程

        from multiprocessing import Process
        import time
        import os


        def test(name):
            print(os.getpid())  # 获取进程号
            print(os.getppid())  # 获取父进程号
            print('%s正在运行' % name)
            time.sleep(3)
            print('%s已经结束' % name)


        if __name__ == '__main__':
            p = Process(target=test, args=('jason',))  # 生成一个进程对象
            p.start()  # 告诉操作系统开设一个新的进程     异步提交
            print(os.getpid())
            print('主')


        """
        在windows中开设进程类似于导入模块
            从上往下再次执行代码
        一定需要在__main__判断语句内执行开设进程的代码

        在linux中是直接将代码完整的复制一份执行
            不需要在__main__判断语句内执行
        """


        class MyProcess(Process):
            def __init__(self, name):
                super().__init__()
                self.name = name

            def run(self):
                print('%s正在运行' % self.name)
                time.sleep(3)
                print('%s已经结束' % self.name)

        if __name__ == '__main__':
            p = MyProcess('jason')
            p.start()
            print('主')

进程的join方法

        from multiprocessing import Process
        import time


        def test(name, n):
            print('%s is running' % name)
            time.sleep(n)
            print('%s is over' % name)


        if __name__ == '__main__':
            p_list = []
            start_time = time.time()
            for i in range(1, 4):
                p = Process(target=test, args=(i, i))
                p.start()
                p_list.append(p)
                # p.join()  # 串行  9s+
            for p in p_list:
                p.join()
            print(time.time() - start_time)

            # p = Process(target=test, args=('jason',))
            # p1 = Process(target=test, args=('kevin',))
            # p2 = Process(target=test, args=('oscar',))
            # p.start()
            # p1.start()
            # p2.start()
            print('主进程')

进程间默认无法交互

        # 进程间数据是相互隔离的
        from multiprocessing import Process

        money = 100


        def test():
            global money
            money = 999


        if __name__ == '__main__':
            p = Process(target=test)
            p.start()
            # 先确保子进程运行完毕了 再打印
            p.join()
            print(money)

对象方法

        """
        1.current_process查看进程号
        2.os.getpid() 查看进程号  os.getppid() 查看父进程进程号
        3.进程的名字，p.name直接默认就有，也可以在实例化进程对象的时候通过关键字形式传入name=''
        3.p.terminate()  杀死子进程  terminate--终止
        4.p.is_alive()  判断进程是否存活	3，4结合看不出结果，因为操作系统需要反应时间。主进程睡0.1即可看出效果
        """

__EOF__

本文作者：祈安
本文链接：https://www.cnblogs.com/jyc666/p/15845505.html
关于博主：没有收拾残局的能力，就别放纵善变的情绪
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！