自我总结25

进程互斥锁

让并发变成串行，牺牲了执行效率，保证了数据安全。

在程序并发执行时，需要修改数据时使用

'''
        mutex = Lock()
        # 加锁
        mutex.acquire()
        # 释放锁
        mutex.release()
'''

import json
import time
from multiprocessing import Process
from multiprocessing import Lock


# 查看余票
def search(user):
    # 打开data文件查看余票
    with open('data.txt', 'r', encoding='utf-8') as f:
        dic = json.load(f)
    print(f'用户{user}查看余票,还剩{dic.get("ticket_num")}...')


# 开始抢票
def buy(user):
    # 先打开获取车票数据
    with open('data.txt', 'r', encoding='utf-8') as f:
        dic = json.load(f)

    # 模拟网络延时
    time.sleep(1)

    # 若有票,修改data数据
    if dic.get("ticket_num") > 0:
        dic['ticket_num'] -= 1
        with open('data.txt', 'w', encoding='utf-8') as f:
            json.dump(dic, f)
        print(f'用户: {user}抢票成功!')

    else:
        print(f'用户: {user}抢票失败!')


# 开始抢票
def run(user, mutex):
    # 并发: 异步执行
    search(user)

    # 串行: 同步执行
    mutex.acquire()
    buy(user)
    mutex.release()


if __name__ == '__main__':
    # 调用Lock()类得到一个锁对象
    mutex = Lock()
    # 加锁:
    # mutex.acquire()
    # 释放锁:
    # mutex.release()

    # 同时来10个用户抢票
    for i in range(10):
        # 并发开启10个子进程
        p = Process(target=run, args=(f'用户{i}', mutex))
        p.start()

队列

先进先出 **补充：堆栈-先进后出 **

管道(阻塞) + 锁

相当于内存中产生一个队列空间，可以存放多个数据，但数据的顺序是由陷进去的排在前面

# 调用方法

q = Queue()
# 添加数据
q.put(1)
# 若队列满了,会原地等待
q.put(2)
# 若队列满了,不会等待直接报错
q.put_nowait(2)

# 获取数据,遵循先进先出
若队列中没数据,会原地等待
q.get()  # 1
若队列中没数据,会直接报错
q.get_nowait()  # 1

q.empty()  # 判断队列是否为空
q.full()  # 判断队列是否满了

实际运用案例

# 调用队列类,实例化队列对象 q
q = Queue(5)  # 若传参队列中可以存放5个数据
# q1 = Queue()  # 若不传参,队列中可以存放无限大的数据,前提硬件能更得上

# put添加数据,若队列中的数据满了,则卡住
q.put(1)
print('进入数据1')
q.put(2)
print('进入数据2')
q.put(3)
print('进入数据3')
q.put(4)
print('进入数据4')
q.put(5)
print('进入数据5')
'''
进入数据1
进入数据2
进入数据3
进入数据4
进入数据5
'''
# 查看队列是否满了
print(q.full())  # True

# q.get(): 获取的数据遵循 "先进先出",若队列中无数据可取,也会卡住
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
# print(q.get())

# get_nowait: 获取数据,队列中若没有,则会报错
# print(q.get_nowait())

# 判断队列是否为空
print(q.empty())  # True
q.put(6)
print('进入数据6')
# 添加数据,若队列满了,则会报错
q.put_nowait(7)
q.put_nowait(8)
q.put_nowait(9)
q.put_nowait(10)

IPC(进程间通信)

进程间数据是相互隔离的，若想实现进程间的通信，可以利用队列

from multiprocessing import Process
from multiprocessing import Queue


def test1(q):
    data = '数据hello'
    q.put(data)
    print('进程1开始添加数据到队列中..')


def test2(q):
    data = q.get()

    print(f'进程2从队列中获取数据{data}')


if __name__ == '__main__':
    q = Queue()# 实例化队列对象q

    p1 = Process(target=test1, args=(q,))
    p2 = Process(target=test2, args=(q,))

    p1.start()
    p2.start()
    print('主')
    
'''

主
进程1开始添加数据到队列中..
进程2从队列中获取数据数据hello

'''

生产者和消费者

生产者：生产数据
消费者：使用数据

- 生活中:
   比如: 卖油条, 一边生产油条, 一边卖油条, 供需不平衡.

- 程序中:
   通过队列,生产者把数据添加队列中,消费者从队列中获取数据.

from multiprocessing import Queue
from multiprocessing import Process

# 生产者
def producer(name, food, q):
    for i in range(9):
        q.put(food)
        data = f'用户{name}制作{food}'
        print(data)

# 消费者
def consumer(name, q):
    while True:
        data = q.get()
        if not data:
            break
        print(f'用户{name}开始吃{data}')


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer, args=('json', '油条', q))
    p2 = Process(target=producer, args=('nick', '煎饼', q))

    c1 = Process(target=consumer, args=('enog',  q))
    c2 = Process(target=consumer, args=('mark',  q))

    p1.start()
    p2.start()

    c1.daemon = True
    c2.daemon = True

    c1.start()
    c2.start()

    p2.join()
    print('主')

线程

线程与进程都是虚拟单位，目的都是为了更好地描述事物

进程：资源单位

线程：执行单位

注意: 只要开启一个进程就会有一个线程(主线程).主线程会在进程结束时,一并销毁

线程才是真正的执行者

为什么要使用线程

节省内存资源

开启进程：

		开辟一个名称空间，没开启一个进程都会占用一份内存资源

		自带一个主线程

开启线程：

		一个进程可以开启多个线程

		线程的开销远小于进程

注意：线程不能实现并行，线程只能实现并发，进程可以实现并行

比喻: 内存就像一个工厂, 子进程就像一个工厂车间, 线程就像车间内的流水线

# 创建线程

from threading import Thread
import time

# 方式一:
def task(name):
    print(f'{name} is running...')
    time.sleep(1)
    print(f'{name} is over...')

if __name__ == '__main__':
    t1 = Thread(target=task, args=('jason', ))
    t1.start()

# 方式二:
class MyThread(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self) -> None:
        print(f'{self.name} is running...')
        time.sleep(1)
        print(f'{self.name} is over...')

if __name__ == '__main__':
    t = MyThread('线程1')
    t.start()
    print('主')

线程对象的属性

is_Alive() # 返回线程是否存活
current_thread().name  # 获取当前线程对象的名字
print(enumerate()) # 返回一个列表,列表中包含当前执行的所有线程对象
print(activeCount()) # 获取当前执行线程的个数       

from threading import Thread
from threading import current_thread
import time


def task():
    print(f'线程开启{current_thread().name}')
    time.sleep(3)
    print(f'线程结束{current_thread().name}')


if __name__ == '__main__':

    t = Thread(target=task)
    print(t.isAlive())
    t.start()  # start方法之后，线程开始活动
    print(t.isAlive())
 
'''

False
线程开启Thread-1
True
线程结束Thread-1

'''

线程互斥锁

线程之间数据是共享的

from threading import Lock()
mutex = Lock()
mutex.acquire()
t1
mutex.release()

from threading import Thread, Lock
import time

mutex = Lock()

n = 100


def task(i):
    print(f'线程{i}启动...')
    global n
    # mutex.acquire()
    temp = n
    time.sleep(0.1)  # 一共等待10秒
    n = temp-1
    print(n)
    # mutex.release()


if __name__ == '__main__':
    t_l = []
    for i in range(100):
        t = Thread(target=task, args=(i, ))
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()

    # 100个线程都是在100-1
    print(n)