day04.19并发编程02

进程的创建

创建进程的方式

• 1.鼠标双击操作桌面一个应用图标>>>创建一个进程
• 2.代码操作>>>创建一个进程

代码创建进程的操作

multiprocess不是一个模块而是python中一个操作、管理进程的包。

利用模块from multiprocessing import Process。

在一个python进程中开启子进程>>>：start方法和并发效果。

from multiprocessing import Process


def f(name):
    print('hello', name)
    print('我是子进程')


if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    time.sleep(1)
    print('执行主进程的内容了')

# 在python中启动的第一个子进程

创建进程的两种方式

# 创建进程的方式一
# 通过对象来创建一个进程
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__':  # windows系统需要的操作，创建进程必须在__main__子代码中
    p = Process(target=task, args=('jason',))  # 创建一个进程对象
    p.start()  # 告诉操作系统创建一个新的进程
    print('主进程')  # 主进程
'''

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

'''
# 创建进程的方式二
# 以继承Process类的形式开启进程的方式

from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()

    def run(self):
        print('你好啊 小姐姐', self.username)
        time.sleep(3)
        print('get out!!!', self.username)


if __name__ == '__main__':
    p = MyProcess('tony')
    p.start()
    print('主进程')    # 主进程

note：

不同的操作系统下创建进程的要求不一样>>>：

在windows中创建进程是以导入模块的方式进行，所以创建进程的代码必须写在__main__子代码中，否则会直接报错；因为在无限制创建进程。

在linux和mac中创建进程是直接拷贝一份源代码然后执行，不需要写在__main__子代码中。

利用进程的创建实现TCP协议下的服务端的高并发效果

把服务端当中将与客户端通信的代码封装成一个函数，之后每来一个客户端就创建一个进程专门做交互，实现并发效果。

# 服务端
import socket
from multiprocessing import Process


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    return server


# 将服务客户端的代码封装成函数(通信代码)
def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())


if __name__ == '__main__':
    server = get_server()
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock,))
        p.start()

# 客户端1
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello big baby~')
    data = client.recv(1024)
    print(data.decode('utf8'))
# 客户端2
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello jason~')
    data = client.recv(1024)
    print(data.decode('utf8'))
# 客户端3
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello tony~')
    data = client.recv(1024)
    print(data.decode('utf8'))

 

并发编程当中进程的join方法

join方法的作用就是让主进程代码等待子进程代码运行完毕再执行。

# 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}')    # 主进程 总耗时:3.244047164916992   start之间是异步的，所以按最长的执行时间计算

note：如果是一个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)    # 999

进程的对象的属性和方法

获取进程号的用处之一就是可以通过代码的方式管理进程。

查看进程号的方法：

1. current_process函数

from multiprocessing import Process, current_process

current_process().pid

         2.利用os模块

 os.getpid()  # 获取当前进程的进程号
 os.getppid()  # 获取当前进程的父进程号

强制结束当前进程的方法：

windows：taskkill关键字

mac/linux：kill关键字

杀死子进程：terminate()

判断子进程是否存活：is_alive()

僵尸进程与孤儿进程

僵尸进程：

所有的子进程在运行结束之后都会变成僵尸进程，还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)；这些信息会被主进程回收，当主程序回收结束就意味着子程序彻底结束。

孤儿进程：

子进程存活着，父进程意外死亡。此时子进程会被操作系统自动接管。

守护进程

会随着主进程的结束而结束。

主进程创建守护进程

　　其一：守护进程会在主进程代码执行结束后就终止

　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

note：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止。

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('皇帝Jason寿终正寝')

互斥锁

当多个进程操作同一份数据的时候会造成数据的错乱！！！

这个时候需要加锁处理(互斥锁)>>>:将并发变成串行,虽然牺牲了效率，但是保证的数据的安全。
互斥锁只在处理数据的部分加锁，不然会严重影响系统程序的运行效率。

代码模拟抢票>>>:

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()

ps：

from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 放锁

行锁：针对行数据加锁，同一时间只能一个人操作

表锁：针对表数据加锁，同一时间只能一个人操作

加锁的目的就是为了保证核心数据的安全。

乐观锁：

乐观锁是对于数据冲突保持一种乐观态度，操作数据时不会对操作的数据进行加锁（这使得多个任务可以并行的对数据进行操作），只有到数据提交的时候才通过一种机制来验证数据是否存在冲突(一般实现方式是通过加版本号然后进行版本号的对比方式实现);

特点：乐观锁是一种并发类型的锁，其本身不对数据进行加锁通而是通过业务实现锁的功能，不对数据进行加锁就意味着允许多个请求同时访问数据，同时也省掉了对数据加锁和解锁的过程，这种方式因为节省了悲观锁加锁的操作，所以可以一定程度的的提高操作的性能，不过在并发非常高的情况下，会导致大量的请求冲突，冲突导致大部分操作无功而返而浪费资源，所以在高并发的场景下，乐观锁的性能却反而不如悲观锁。

悲观锁：

悲观锁是基于一种悲观的态度类来防止一切数据冲突，它是以一种预防的姿态在修改数据之前把数据锁住，然后再对数据进行读写，在它释放锁之前任何人都不能对其数据进行操作，直到前面一个人把锁释放后下一个人数据加锁才可对数据进行加锁，然后才可以对数据进行操作，一般数据库本身锁的机制都是基于悲观锁的机制实现的;

特点：可以完全保证数据的独占性和正确性，因为每次请求都会先对数据进行加锁， 然后进行数据操作，最后再解锁，而加锁释放锁的过程会造成消耗，所以性能不高;