一.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.远程时间同步
"""
# 课下看看简易qq程序

二.操作系统的发展史

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

三.多道技术

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

四.进程理论

4.1 进程简介

# 进程与程序的区别
    程序:一堆代码(死的)
    进程:正在运行的程序(活的)
    
# 单核情况下的进程调度
    进程调度算法演变
        1.FCFS 先来先服务
            对短作业不友好
        2.短作业优先调度算法
            对长作业不友好
        3.时间片轮转法+多级反馈队列
            先分配给新的多个进程相同的时间片
            之后根据进程消耗的时间片多少分类别......

4.2 进程三状态

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

4.3 同步与异步

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

这里举一个例子：

比如我们去银行办理业务，可能会有两种方式：

第一种 ：选择排队等候；

第二种 ：选择取一个小纸条上面有我的号码，等到排到我这一号时由柜台的人通知我轮到我去办理业务了；

第一种：前者(排队等候)就是同步等待消息通知，也就是我要一直在等待银行办理业务情况；

第二种：后者(等待别人通知)就是异步等待消息通知。在异步消息处理中，等待消息通知者(在这个例子中就是等待办理业务的人)往往注册一个回调机制，在所等待的事件被触发时由触发机制(在这里是柜台的人)通过某种机制(在这里是写在小纸条上的号码，喊号)找到等待该事件的人。
例子

4.4 阻塞与非阻塞

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

五.创建进程

方式①：

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('主')

方式②：

from multiprocessing import Process
import time
import os


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方法

通过join方法让子程序先执行，主程序后执行

import os
from multiprocessing import Process
import time


def test(name):
    # print(os.getpid())
    print('%s正在运行' % name)
    time.sleep(1)
    print('%s已经结束' % name)
    # print(os.getpid())


if __name__ == '__main__':
    P_list = []
    start_time = time.time()
    for i in range(1, 4):
        p = Process(target=test, args=(i, ))  # 生成一个进程对象
        p.start()  # 告诉操作系统开设一个新的进程
        P_list.append(p)
    for p in P_list:
        p.join()
    print('主程序')
    # print(os.getpid())
    print(time.time()-start_time)

七.进程间无法交互

# 进程间数据是相互隔离的
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)  # 结果是100这个print打印的money是主进程的

八.对象方法

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