网络并发

• 代码创建进程

• join方法

• 进程间数据默认隔离

• 进程间数据默认隔离

• 进程对象相关属性和方法

• 僵尸进程与孤儿进程

• 守护进程

• 互斥锁

 

代码创建进程

"""
创建进程的方式有哪些
    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=('shadiao',))  # 创建一个进程对象
    p.start()  # 告诉操作系统创建一个新的进程
    print('主进程')

 

   
"""
强调：不同的操作系统创建进程的要求不一样
    在Windows中创建进程的是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
    否则会直接报错 因为在无限制创建进程
    在Linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
"""

# 创建进程的第二种方式

from multiprocessing import Process
import time
​
class MyProcess(Process):
    def __init__(self,username):
        self.username = username
        super().__init__()
    def run(self):
        print('hi',self.username)
        time.sleep(3)
        print('f**k you',self.username)
if __name__ == '__main__':
    p = MyProcess('Mary')
    p.start()
    print('主进程')

进程实现并发

"""
将与客户端通信的代码封装成一个函数
之后每一个客户端就创建一个进程专门做交互
"""

join方法

# 让主进程代码等待子进程代码运行完毕再执行
1.join方法的简单应用
2.如何真正理解等待的过程

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}')  # 主进程 总耗时:3.151747941970825
    # 如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和

"""
需求：想让p.start()之后的代码 等待子进程全部运行结束之后再打印
    1.傻叼做法：直接sleep
        肯定不行 因为子进程运行的时间不可控
    2.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)

"""默认隔离 但是可以通过一些技术打破"""

进程对象属性和方法

"""
进程号如何查找
    Windows：    tasklist结果集中PID
    mac:        ps -ef
"""
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和一些运行过程中的纪律便于主进程查看(短时间保存)
    这些信息会被主进程回收(僵尸歇逼了)
    1.主进程正常结束
    2.调用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('主公歇逼了')

互斥锁

"""
每逢节假日抢票
    手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了
    之后回到查询页面发现确实显示没票了
    
    上午10:00打开买票软件查看票数 系统给你发过来的是10:00对应的数据
    只要你页面不刷新不点击下一步 那么页面数据永远展示的是10:00的
"""

# 代码模拟抢票
import json
from multiprocessing import Process
import time
import random
​
​
# 查票
def search(name):
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print(f'{name}查询当前余票:%s' % data.get('ticket_num'))
​
​
# 买票
def buy(name):
    '''
    点击买票是需要再次查票的 因为期间其他人可能已经把票买走了
    '''
    # 1.查票
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 2.判断是否还有余票
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print(f'{name}抢票成功')
    else:
        print(f'{name}抢票失败 没有余票了')
​
​
def run(name):
    search(name)
    buy(name)
​
​
# 模拟多人同时抢票
if __name__ == '__main__':
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i,))
        p.start()

        
========================================================
当多个进程操作同一份数据的时候会造成数据的错乱
这个时候需要加锁处理(互斥锁)
    将并发变成串行 牺牲了效率但是保证数据的安全
   
互斥锁并不能轻易使用  容易造成死锁现象
互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率
==========================================================
查票可以一次性给所有人看 但是买票环节必须'排队'：互斥锁
​
from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 放锁
​
"""
锁相关知识
    行锁：针对行数据加锁 同一时间只能一个人操作
    表锁：针对表数据加锁 同一时间只能一个人操作
    悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
        优点：可以完全保证数据的独占性和正确性，因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高;
        缺点：因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高
锁的应用范围很广 但是核心都是为了保证数据的安全
    乐观锁：总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下，在此期间有没有别人去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量
    优点：乐观锁是一种并发类型的锁，其本身并不对数据进行加锁，而是通循环重试CAS进而实现锁的功能，其不对数据进行加锁就意味着允许多个线程同时读取（因为根本没有加锁操作）数据，但是只有一个线程可以成功更新数据，并导致其他要更新数据的线程回滚重试，这种方式大大的提高了数据操作的性能，因为整个过程中并没有“加锁”和“解锁”操作，因此乐观锁策略也被称为无锁编程。
"""