进程互斥锁，队列，IPC进程间通信，生产者与消费者，线程，线程对象的属性，先行互斥锁

进程互斥锁：

让并发变成串行, 牺牲了执行效率, 保证了数据安全.在程序并发执行时,需要修改数据时使用.

队列

队列：先进先出

​ 相当于内存中产生一个队列空间，先进先出，

​ 可以存放多个数据，但数据的顺序是由先进去的排在前面.

堆栈

先进后出，后进后出。

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

# put添加数据,若队列中的数据满了,则卡住
q.put(1)
print('进入数据1')
q.put(2)
print('进入数据2')
q.put(3)
print('进入数据3')

# 查看队列是否满了
print(q.full())  # True

# 添加数据,若队列满了,则会报错
# q.put_nowait(6)

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

# print(q.get())

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

进入数据1
进入数据2
进入数据3
False
1
2
3
True
进入数据6

IPC进程间通信

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

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

    p1.start()
    p2.start()

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

生产者与消费者

生产者：

生产数据的

消费者：

使用数据的

生活中：

比如-->：卖油条，一边生产，一边卖，供需不平衡。

程序中：

通过队列，生产者把数据添加队列中，消费者从队列中获取数据。

from multiprocessing import Queue, Process
import time

# 生产者
def producer(name, food, q):  # 生产名, 食物, 队列
    for i in range(9):
        data = food, i
        msg = f'用户{name}开始制作{data}'
        print(msg)
        q.put(data)
        time.sleep(0.1)

# 消费者
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=('tank', '油条', q))
    p2 = Process(target=producer, args=('华农兄弟', '竹鼠', q))

    # 生产消费者
    c1 = Process(target=consumer, args=('egon', q))
    c2 = Process(target=consumer, args=('jason', q))

    p1.start()
    p2.start()

    c1.daemon = True
    c2.daemon = True

    c1.start()
    c2.start()

    p2.join()
    print('主')

线程

1.什么是线程？

​ 线程与进程都是虚拟单位。

​ 目的：为了更好的描述某种事物。

进程：资源单位

线程：执行单位

开启一个进程，一定会有一个线程，线程才是真正执行者。

2.为什么要使用线程？

节省内存资源

开启进程：

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

2.会自带一个线程。

开启线程

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

2.线程的开销远小于进程。

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

比喻：主进程就像一个工厂，子进程就像一个工厂车间，线程就像车间内的流水线。

from threading import Thread
mport time
# 开启线程方式2:
class MyThread(Thread):
    def run(self):
        print('线程开启')
        time.sleep(1)
        print('线程结束')

t = MyThread()
t.start()

线程开启
线程结束

线程对象的属性

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)
    t.daemon = True
    t.start()
    
线程开启Thread-1
主

先行互斥锁

线程之间数据是共享的.

​