pythonNet day04

本地套接字

作用：用于本地不同程序间的进行数据传输

本地套接字的创建流程

1、创建套接字对象

　　sockfd = socket(AF_UNIX,SOCK_STREAM)

2、绑定本地套接字文件,如果文件不存在，则自动创建文件（绑定套接字文件）

　　sockfd.bind(file)

　　判断一个文件夹下是否有某个文件　　os.path.exists(‘./tcp_client.py’)

　　删除一个文件　　os.remove(file)　　os.remove(file)

3、监听　　listen

4、接收发送消息　　recv　　send

 1 from socket import * 
 2 import os 
 3 
 4 sock_file =  './sock'    # 使用哪个文件作为套接字文件
 5 
 6 if os.path.exists(sock_file):# 判断文件是否已经存在
 7     os.unlink(sock_file)
 8 
 9 sockfd = socket(AF_UNIX,SOCK_STREAM)    # 创建本地套接字
10 
11 sockfd.bind(sock_file)    # 绑定
12 sockfd.listen(5)    # 监听
13 
14 while True:
15     c,addr = sockfd.accept()     # 建立连接
16     while True:
17         data = c.recv(1024)
18         if not data:
19             break
20         print(data.decode())
21     c.close()
22 sockfd.close()

服务端

 1 from socket import * 
 2 
 3 sock_file = "./sock"    # 确保通信两端用相同的套接字文件
 4 
 5 sockfd = socket(AF_UNIX,SOCK_STREAM)    # 创建套接字
 6 
 7 sockfd.connect(sock_file)    # 链接
 8 
 9 while True:
10     msg = input("Msg>>")
11     if msg:
12         sockfd.send(msg.encode())
13     else:
14         break 
15 
16 sockfd.close()

客户端

多任务编程

意义：充分利用计算机的资源提高程序的运行效率

定义：通过应用程序利用计算机多个核心，达到同时执行多个任务的目的

实施方案：多进程、多线程

并行：多个计算机核心在同时处理多个任务，多个任务之间是并行关系

并发：计算机同时处理多个任务，内核在多个任务间不断切换，达到好像在同时处理的运行效果。此时多个任务实际为并发关系

进程：程序在计算机中运行一次的过程

程序：是一个可执行文件，是静态的，占有磁盘，不占有计算机运行资源

进程：进程是一个动态的过程描述，占有CPU内存等计算机资源的，有一定的生命周期

* 同一个程序的不同执行过程是不同的进程，因为分配的计算机资源等均不同

进程的创建过程

1、用户启动一个程序或者进程创建，发起进程创建

2、操作系统接收用户请求，分配计算机资源，创建进程

3、操作系统分配进程资源给用户使用，分配资源

4、用户利用操作系统提供的进程完成任务　　利用资源完成任务

CPU时间片：如果一个进程占有计算机核心，我们称为该进程在CPU时间片上。多个任务实际对CPU会进行争夺，一般由操作系统分配CPU时间片

PCB进程控制块：在操作系统中，进程创建后会自动产生一个空间存放进程消息，称为进程控制块

进程信息包括：进程PID，进程占有的内存位置，创建时间，创建用户。。。。。。

进程PID:进程在操作系统中的唯一编号，大于0整数，由系统自动分配

进程信息查看命令：　　ps -aux

进程特征：

　　1、进程是操作系统分配计算机资源的最小单位

　　2、每一个进程都有自己单独的虚拟内存空间

　　3、进程间的执行相互独立，互不影响

进程的状态

1、三态

　　1、就绪态：进程具备执行条件，等待系统分配CPU

　　2、运行态：进程占有CPU处理器，处于运行状态

　　3、等待态：进程暂时不具备运行条件，需要阻塞等待，让出CPU

2、五态（增加新建态和终止态）

　　4、新建态：创建一个新的进程，获取资源的过程

　　5、终止态：进程结束释放资源的过程

　　pa -sux　　—> 查看进程状态

　　D 等待态（不可中断等待）（阻塞）
　　S 等待态（可中断等待）（睡眠）
　　T 等待态（暂停状态）
　　R 运行态（就绪态运行态）
　　Z 僵尸态

　　+ 前台进程（能在终端显示出现象的）
　　< 高优先级
　　N 低优先级
　　l 有进程链接
　　s 会话组组长

进程优先级

　　优先级决定一个进程的执行权限和占有资源的优先程度

　　查看进程优先级

　　　　top：动态的查看进程优先级　　< > 翻页

　　　　取值范围：-20 —– 19 -20优先级最高

　　nice：指定优先级运行程序

　　nice -9　./while.py　　（以9的优先级运行程序）

　　sudo nice –9 ./while.py　　（以-9的优先级运行程序）（0以下的优先级需要加sudo）

父子进程

在系统中除了初始化进程每个进程都有一个父进程，可能有0个或者多个子进程。由此形成父子进程关系。我们认为每个进程都是父进程发起请求创建的。

进程（process）

查看进程数：pstree

查看父进程PID：ps -ajx

import os

pid = os.fork()　创建一个新的进程

返回值：失败返回一个负数。

　　　　成功在原有的进程中返回子进程的PID，然后在新的进程中返回0

1、子进程会复制父进程全部代码段，包括fork前的代码

2、子进程从fork的下一句开始执行

3、父进程中fork返回值即为子进程的PID号

4、父进程不一定先执行

3、父子进程通常会根据fork返回值的差异选择执行不同的代码（使用if结构）

4、父子进程在执行上互不干扰，执行顺序不确定

5、父子进程空间独立，各自修改各自的内容，互不影响

6、子进程虽然复制父进程内容，但是也由自己的特有属性特征，比如：PID号PCB内存空间

 1 import  os 
 2 from time import sleep
 3 
 4 pid = os.fork()
 5 
 6 if pid < 0:
 7     print("创建进程失败")
 8 
 9 #子进程执行部分
10 elif pid == 0:
11     print("新进程创建成功")
12 
13 #父进程执行部分
14 else:
15     sleep(1)
16     print("原来的进程")
17 
18 print("程序执行完毕")
19 
20 # 新进程创建成功
21 # 原来的进程
22 # 程序执行完毕

View Code

 1 import os 
 2 from time import sleep 
 3 
 4 a = 1
 5 pid = os.fork()
 6 if pid < 0:
 7     print("创建进程失败")
 8 elif pid == 0:
 9     print("子进程")
10     print("a = ",a)
11     a = 10000
12     print("a = ",a)
13 else:
14     sleep(1)
15     print("父进程")
16     print("parent a :",a)    # a = 1
17 
18 # 子进程
19 # a =  1
20 # a =  10000
21 # 父进程
22 # parent a : 1

子进程和父进程的变量域

由上可知，创建一个子进程，子进程在复制完父进程的代码后，会另外开辟一块内存空间，和父进程相互独立，互不影响

进程相关函数使用

os.getpid() 获取当前进程的PID号

　　返回值：返回PID号

os.getppid() 获取父类进程的进程号

　　返回值：返回PID号

 1 import os 
 2 from time import sleep
 3 
 4 pid = os.fork()
 5 
 6 if pid < 0:
 7     print("创建进程失败！")
 8 # 子进程
 9 elif pid == 0:
10     print("Child PID:",os.getpid())
11     print("Get parent PID",os.getppid())
12 # 父进程
13 else:
14     sleep(0.5)
15     print("Parent PID:",os.getpid())
16     print("Get child PID:",pid)

View Code

os._exit(status) 退出进程

　　参数：进程的退出状态　　整数

sys.exit([status]) 退出进程

　　参数：默认为0　　如果传入一个整数则表示退出状态；如果是字符串则表示退出时打印内容

　　sys.exit([status])可以通过捕获SystemExit异常阻止退出

1 import os,sys
2 
3 # os._exit(0)
4 try:
5     sys.exit("退出")
6 except SystemExit as e:
7     print("退出原因：",e)    #退出原因： 退出
8 
9 print("Process end")