标签：__ name 编程 网络 print 进程 import socket
网络编程(四)
昨日内容
UDP协议
import socket # 服务端
server = socket.socket(type=socket.SOCK_DGRAM) # 自己指定UDP协议(默认是TCP协议)
server.bind(('127.0.0.1', 8080)) # 和TCP几乎一样，写入地址和端口号
msg, addr = server.recvfrom(1024) # 待接收
print('msg>>>:', msg.decode('utf8'))
print('addr>>>:', addr) # 额外打印出端口号，为了确定是哪个客户端
server.sendto(b'hello baby', addr)
import socket # 客户端
client = socket.socket(type=socket.SOCK_DGRAM) # 自己指定UDP协议(默认是TCP协议)
server_addr = ('127.0.0.1', 8080) # 查找通讯录
client.sendto(b'hello server baby', server_addr)
msg, addr = client.recvfrom(1024)
print('msg>>>:', msg.decode('utf8'))
print('addr>>>:', addr)
不同处
UDP TCP
socket.socket(type=socket.SOCK_DGRAM) socket.socket()
recvfrom() recv()
sendto() send()
操作系统发展史
graph TB 无操作系统-->联机批处理-->脱机批处理
一句话概括操作系统发展史：为了最大的提升CPU的利用率
多道技术
IO操作：IO操作中的读写操作不是我们平时所说读写看，而是将数据加载到硬盘中，我们叫IO流的写操作，即输入流，将硬盘加载出来，叫做IO流的读操作，即输出流。
串行：多个程序依次执行
多道：利用IO操作的间隙：看似多个程序同时执行
进程理论
程序：代码集合体
进程：正在执行的代码集合体
时间片轮转、优先级、多级反馈队列：
这篇博客描述的很好:调度算法——时间片轮转、优先级、多级反馈队列（例题详细！！！）
并发与并行
'''描述的是任务的的工作方式'''
并发:看上去像同时在执行就可以称之为是并发(单个CPU就可以)
并行:必须同一时间同时执行(必须要有多个CPU才可以)
高并发量：1星轨，2星轨······
同步与异步
'''描述的是任务的提交方式'''
同步：提交完任务之后原地等待任务的结果 期间不做任何事（类似串行）
异步: 提交完任务之后不原地等待结果 结果通过反馈机制获取 （类似多道）
阻塞与非阻塞
'''描述的是任务的执行状态'''
阻塞:阻塞态
非阻塞:就绪态 运行态
今日学习内容
代码创建进程
第一种：
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__':
p = Process(target=task, args=('eason',)) # 创建一个进程对象
p.start() # 告诉操作系统创建一个新的进程并启动进程中的所有功能
print('主进程')
"""
强调:不同的操作系统创建进程的要求不一样
在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
否则会直接报错 因为在无限制创建进程
在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
"""
第二种：
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, username): # 重写__init__方法
self.username = username # 新增一个参数
super().__init__() # 重新调用原始方法
def run(self):
print('我是',self.username)
time.sleep(3)
print('我也是',self.username)
if __name__ == '__main__':
p = MyProcess('eason')
p.start()
print('主进程')
进程实现并发
'''服务端'''
import socket
from multiprocessing import Process
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
# 将服务客户端的代码封装成函数(通信代码)
def talk(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
if __name__ == '__main__':
while True:
sock, addr = server.accept()
p = Process(target=talk, args=(sock, ))
p.start()
'''客户端'''
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
client.send(b'多个客户端不同的消息')
data = client.recv(1024)
print(data.decode('utf8'))
join方法
from multiprocessing import Process
import time
def task(name, n):
print(f'{name} is running')
time.sleep(n)
print(f'{name} is over')
if __name__ == '__main__':
p1 = Process(target=task, args=('jason', 1))
p2 = Process(target=task, args=('tony', 2))
p3 = Process(target=task, args=('kevin', 3))
start_time = time.time()
p1.start() # 调用一个工作一秒的对象
p2.start() # 调用一个工作两秒的对象
p3.start() # 调用一个工作三秒的对象
p1.join() # 结束一个工作进程
p2.join() # 结束一个工作进程
p3.join() # 结束一个工作进程
end_time = time.time() - start_time # 计算三个进程都工作完的时间
print('主进程', f'总耗时:{end_time}') # 主进程 总耗时:三秒
因为三个工作进程是并发启动的，总共用时取决于时间最长的那个
注意：
如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和
因为每项工作执行完后才会继续下一项工作
进程间数据默认隔离
# 内存可以看成是有很多个小隔间组成的 彼此不干扰
from multiprocessing import Process
money = 999
def task():
global money # 局部修改全局不可变类型
money = 666
if __name__ == '__main__':
p = Process(target=task)
p.start()
p.join() # 确保子进程代码运行结束再打印money
print(money)
"""默认隔离 但是可以通过一些技术打破"""
进程对象属性
1.查看进程号的方法
1.1.current_process函数
from multiprocessing import Process, current_process
current_process().pid
# 获取进程号的用处之一就是可以通过代码的方式管理进程
windows taskkill关键字
mac/linux kill关键字
1.2.os模块
os.getpid() # 获取当前进程的进程号
os.getppid() # 获取当前进程的父进程号
2.杀死子进程
terminate()
3.判断子进程是否存活
is_alive()
僵尸进程与孤儿进程
僵尸进程：终止主进程时，主进程会默认等待子进程结束才会结束
所有子进程在运行结束之后就会变成僵尸进程，因为没有主进程去接受这个子进程了
这写子进程短时间保留着pid和一些运行过程的中的记录便于主进程查看
这些信息会被主进程回收
- 主进程正常结束
- 调用join方法
孤儿进程：子进程存活着 父进程意外死亡，子进程会被系统自动接管
亚索路过~
守护进程
"""
守护即死活全部参考守护的对象
对象死立刻死
"""
from multiprocessing import Process
import time
def task(name):
print(f'主进程{name}启动')
time.sleep(3)
print(f'主进程{name}结束了')
if __name__ == '__main__':
p = Process(target=task, args=('子进程',))
# 必须写在start前面
# p.daemon = True # 将子进程设置为守护进程:主进程结束 子进程立刻结束
p.start()
print('主进程结束了')
结果：
主进程结束了
主进程子进程启动
主进程子进程结束了
主进程被结束但是子进程还是继续运行到结束
from multiprocessing import Process
import time
def task(name):
print(f'主进程{name}启动')
time.sleep(3)
print(f'主进程{name}结束了')
if __name__ == '__main__':
p = Process(target=task, args=('子进程',))
# 必须写在start前面
p.daemon = True # 将子进程设置为守护进程:主进程结束 子进程立刻结束
p.start()
print('主进程结束了')
结果：
主进程结束了
主进程被杀死
互斥锁
from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire() # 抢锁
mutex.release() # 放锁
针对互斥锁
标签：__,name,编程,网络,print,进程,import,socket
来源： https://www.cnblogs.com/easonqu/p/16167282.html
本站声明：
1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。