并发、并行和多进程

发表于 更新于 分类于

加入链接循环的套接字服务端

1
2
3
4
5
6
7
8
9
10
11
import socket
sever = socket.socket()
sever.bind(('127.0.0.1', 8087))
sever.listen(5)
while True:
    sock, addr = sever.accept()
    data = sock.recv(1024)
    print(data)
    sock.send(data.upper())
    sock.close()
sever.close()

加入通信循环的套接字服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import socket
server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

server.bind(('127.0.0.1',81))


server.listen(1)

print('开始等待客户端连接了')
while True:

    sock,addr=server.accept()
    print(sock)
    print('客户端的地址是：',addr)


    # 等待客户端发送过来的数据，如果客户端没有发送数据，会一直等着
    while True:
        try:
            data=sock.recv(1024)
            if len(data)==0: # 这个表示客户端正常断开了，结束通信循环
                break
            print(data.decode('utf-8'))
            sock.send(data.upper())
        except Exception as e:
            print(e) #客户端非正常断开，需要异常捕获
            break


    sock.close()
server.close()

基于UDP的套接字客户端和服务端(了解)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import socket

# udp的服务端
server = socket.socket(type=socket.SOCK_DGRAM)

# 监听地址和端口
server.bind(('127.0.0.1', 82))

# 不需要listen，直接建立链接
print('等待客户端发送数据：')
while True:
#recvfrom回返回数据和客户端的地址
    data,addr = server.recvfrom(1024)
    print(data)
    print(addr)
    server.sendto(data.upper(), addr)

server.close()

操作系统的发展史

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1 手工操作——穿孔卡片
    -用户独占全机
    -CPU的利用不充分
2 批处理
    -把一个操作整个写到磁带中，以后要进行这个操作，直接拿着磁带，读入即可
    -脱机批处理
    -联机批处理
    
3 多道程序系统(重要)
    -当一道程序因I/O请求而暂停运行时，CPU便立即转去运行另一道程序
    -各道程序轮流地用CPU，并交替运行
4 分时系统(重要)
    -多个程序在运行，时间片的概念，cpu执行完固定的时间，就会转去另一个程序
5 通用操作系统
    多道批处理系统，分时


io操作：（通通不占用cpu）(重要)
    键盘输入，从硬盘拿数据，从网络加载数据--->都叫输入
    显示在显示器，写到硬盘，从网络发送数据--->都叫输出

进程基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元

(重要)↓↓↓
# 进程是资源分配的最小单位，线程是cpu执行的最小单位
# 一个程序运行，最少有一个进程
# 一个进程里最少有一条线程

(重要)↓↓↓
# 进程和程序的区分
    -程序可以作为一种软件资料长期存在，而进程是有一定生命期的。
    -程序是永久的，进程是暂时的。

(重要)↓↓↓
# 进程的状态（）
    -就绪态：可以被cpu调度执行了，还没有执行，排着队
    -运行态：在cpu中运行，正在运行（如果到了时间片，也会被调度出去，调度出去的程序是就绪态）
    -阻塞态：io操作，把数据加载到内存中

img

并发和并行

1
2
3
4
5
6
7
并发：（你在跑步，鞋带开了，停下跑步，系鞋带，系完以后，继续跑步，在一个时间段内来看，你干了多个事）
    -单核下的并发
    :在一个时间段内，处理多件事
    
并行：（你在跑步，你用随身听在听着，同一时刻，在干多个事）
    -只有多核才涉及到并行
    ：在某一个时刻，有多件事同时被处理

开启多进程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from multiprocessing import Process


#如果在win下开多进程，必须写main，否则报错(注意)
import time
def wirte_file(s):

    time.sleep(5)
    with open('a.txt','a') as f:
        f.write(s)
        f.write('\n')

if __name__ == '__main__':
    time.sleep(5)
    # wirte_file()
    # 开启多进程的第一个方式
    p=Process(target=wirte_file,args=['lqz is nb'])
    # 执行该进程
    p.start()


    # 又开了一个进程
    p1 = Process(target=wirte_file,args=['egon is dsb'])
    # 执行该进程
    p1.start()

总结

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1 基于socket写TCP的客户端和服务端
    -加入链接循环
    -加入通信循环
    -客户端主动断开---->服务端一直收空
    -客户端强制断开---->服务端会报错
    -同一时刻，只能有一个客户端与服务端交互
    
2 基于UDP的客户端和服务端
    -数据不可靠，应用场景比较少
    
3 并发编程（进程，线程，协程）

4 进程：
    -资源分配的最小单位，线程是cpu调度的最小单位
    -食谱：程序
    -拿到食谱做法的过程，叫进程
    -进程：程序运行的过程，一堆数据+做一件事的过程的集合
    
5 python中如何开启进程
    -p=Process(target=task)
    -p.start()