python中并发编程基础1

时间:2024-04-24 23:03:38

并发编程基础概念

1.进程。
  1. 什么是进程?

    正在运行的程序就是进程。程序只是代码。

  2. 什么是多道?

    多道技术:

    1.空间上的复用(内存)。将内存分为几个部分,每个部分放入一个程序,这样同一时间在内存中就有了多道程序。

    2.时间上的复用(CPU的分配)。只有一个CPU,如果程序在运行过程中遇到了I/O阻塞或者运行时间足够长。操作系统会按照算法将CPU分配给其他程序使用,依次类推。直到第一个程序被重新分配到CPU会继续运行。

    多道技术中的问题解决:

    空间复用:程序之间的内存必须分割。这种分割需要在硬件层面实现,由操作系统控制。保证安全性和稳定性。

  3. multiprocessing模块的使用

    python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源,python中大部分情况需要使用多进程。python提供了multiprocessing模块。

    multiprocessing模块是用来开启子进程,并可以在子进程中定制任务。

  4. Process类

    process类的作用是用来创建进程的类。

    Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)
    强调:

    1. 需要使用关键字的方式来指定参数

    2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号

    参数介绍:

    1、group参数未使用,值始终为None

    2、target表示调用对象,即子进程要执行的任务

    3、args表示调用对象的位置参数元组,args=(1,2,'ming',)

    4、kwargs表示调用对象的字典,kwargs={'name':'ming','age':20}

    5、name为子进程的名称

  **方法介绍**:

1、p.start():启动进程,并调用该子进程中的p.run()

2、p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  

3、p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁

4、p.is_alive():如果p仍然运行,返回True

5、p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
  **属性介绍:**

1、p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置

2、p.name:进程的名称

3、p.pid:进程的pid

4、p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)
5、p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)

5.Process类的使用

  
#创建进程的第一种方式
##注意:在windows 中,开启一个子进程就是完全复制一个父进程的代码并运行。如果不写在if __name__ == '__main__':下面会形成一个无穷的循环。if __name__ == '__main__':的作用是以当前文件运行__name__ 会== '__main__' from multiprocessing import Process
import os
def task():
print('task run')
print('子进程task', os.getpid())
print('子进程task父进程', os.getppid()) if __name__ == '__main__':
#创建子进程p = Process
p = Process(target=task, name= '这是子进程')
p.start() # 给操作系统发送通知 要求操作系统开启进程,会自动调用run()方法
print('py文件进程', os.getpid())
print('py文件进程的父进程', os.getppid()) ###输出结果
py文件进程 10532
py文件进程的父进程 15348
task run
子进程task 4356
子进程task父进程 10532
  
#开启进程的第二种方式
#创建一个类,该类继承Process类,覆盖Process中的run方法,其优势是 可以自定义 进程的属性和行为 来完成一些额外任务 例如下载
from multiprocessing import Process
import os
class MyProcess(Process):
def __init__(self, url):
self.url = url
super().__init__()
def run(self): #方法名必须是run
print('下载文件。。。。', self.url)
print('子进程run的进程ID', os.getpid())
print('子进程run的父进程ID', os.getppid())
if __name__ == '__main__':
p = MyProcess('')
p.start() #会自动执行run
print('py文件的进程ID', os.getpid())
print('py文件的父进程ID', os.getppid())
  1. 进程之间的内存空间是隔离的

    from multiprocessing import Process
    import time

    a = 1002020212

    def test():
    global a
    a = 33520
    print('test进程的a', a)

    if __name__ == '__main__':
    p = Process(target=test) #创建进程
    p.start() #启动进程

    time.sleep(1)
    print('py文件进程中的a', a) ###输出结果
    test进程的a 33520
    py文件进程中的a 1002020212
    结论:
    1.子进程中的数据修改,不会影响父进程。
    2.子进程的创建和父进程无关。
  2. Process对象的join方法

    join方法的作用是:父进程等待子进程结束。

    from multiprocessing import Process
    import time

    def task(num):
    # time.sleep(2)
    print('我是%s号进程' % num)

    if __name__ == '__main__':
    start_time = time.time()
    ps = []
    for i in range(5):
    s = Process(target=task, args=(i,))
    s.start()
    ps.append(s)
    for n in ps:
    n.join(0.04)
    print(time.time()-start_time)
    print('over')
  3. Process对象常用属性

    from multiprocessing import Process
    import time

    def test():
    time.sleep(3)
    print('life is so short, i use python')

    if __name__ == '__main__':
    p = Process(target=test, name='daidai')
    p.start()
    print(p.name) #进程名
    print(p.is_alive()) #进程是否存活
    # p.terminate() #终止进程
    print(p.pid) ###
    daidai
    True
    20108
    life is so short, i use python
  4. 孤儿进程和僵尸进程

    孤儿进程:是指父进程已经终止,但是自己还在运行

    孤儿进程是无害的:例如QQ打开了浏览器, 然后QQ关闭,浏览器运行

    僵尸进程:是指子进程完全执行完所有的任务,已经终止了但是还残留一些信息。(进程id 和 进程名等)

    但是父进程没有处理这些残留信息,导致残留信息占用系统内存。

    当出现大量的僵尸进程时,会占用系统资源,可以将他的父进程杀掉,僵尸成了孤儿,然后操作系统会负责收回内存。

  5. 基于多进程的TCP套接字通信

    

##基于多进程实现并发通信服务器

from socket import *
from multiprocessing import Process
import struct server = socket()
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 33520))
server.listen()
def communicate(c, addr):
try:
while True:
data = c.recv(4) #
msg_len = struct.unpack('i', data)[0]
msg_data = c.recv(msg_len) #
if not msg_data:
err_info = '对方正在输入!'
err_info_data = err_info.encode('utf-8')
back_len_data = struct.pack('i', len(err_info_data))
c.send(back_len_data)
c.send(err_info_data)
back_len = struct.pack('i', len(msg_data))
c.send(back_len)
c.send(msg_data)
print(msg_data.decode('utf-8'))
except Exception as e:
print(e) if __name__ == '__main__':
while True:
c, addr = server.accept()
p = Process(target=communicate, name=None, args=(c, addr))
p.start() #客户端,可开启多个,但是每连接一个就开启一个进程
from socket import *
import struct client = socket()
client.connect(('127.0.0.1', 33520))
while True:
msg = input('请输入发送的消息:').strip()
msg_data = msg.encode('utf-8')
msg_len_s = struct.pack('i', len(msg_data))
client.send(msg_len_s)
client.send(msg_data)
data_len = client.recv(4) #收到消息长度
length = struct.unpack('i', data_len)[0]
data = client.recv(length)
back_msg = data.decode('utf-8')
print('返回的消息:%s' % back_msg)