python中进程，线程和协程

进程：资源分配的最小单位
线程：任务分配的最小单位
协程：用户模式下轻量级的线程，系统不管这部分的调度

多进程

from multiprocessing import Process
import os

def run(desc):
    while True:
        print('子进程{}开始'.format(os.getpid())


if __name__ == "__main__":
    p = Process(target=run, args=('测试',))
    p.start()
    p.join(timeout=3) # join会阻塞当前进程,直到p进程执行结束之后才会继续执行, timeout是等待时间
    
    while True:
        print('这是主进程', os.getpid())

# p.daemon 设置守护进程，主进程消失，子进程也消失

全局变量在多个进程之间不会共享

解决变量多线程不能共享问题

# 使用队列在进程之间共享数据
from multiprocessing import Process, Queue
import queue
# 往队列中写入数据
def write(q):
    print('写进程开始')
    for i in 'abcdefg':
        try:
            q.put(i)
            print('{}已经被写入'.format(i))
        except queue.Full:
            print('队列已经满了')

# 从队列中读取数据
def read(q):
    print('读进程开始')
    while True:
        try:
            value = q.get(block=False) # block表示队列空的时候读取会报错
        except queue.Empty:
            print('队列是空的')

if __name__ == "__main__":
    pw = Process(target=write,args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pr.start()

使用线程锁来解决多线程数据共享造成紊乱问题

from threading import Thread, Lock
num = 100
def run(n):
    global num
    with Lock()  # 加上锁，保证了数字不会紊乱
        for i in range(1000):
            num += n
            num -= n
    return num


if __name__ = "__main__":
    t1 = Thread(target=run, args=(3,))
    t2 = Thread(targe=run, args=(10,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    

使用多线程实现生产者消费者模型

import threading
import time
import random
from queue import Queue


cond = threading.condition()
# 生产者
def producer(q):
    cond.acquire()
    while True:
        value = random.randint(1,100)
        print('{}已经入队列'.format(value))
        try:
            q.put(value,block=False)
        except queue.Full
            print('队列已经满了')

# 消费者
def consumer(q):
    cond.acquire()
    while True:
        try:
            value = q.get(block=False)
            print('{}已经出队列'.format(value))
        except queue.Empty:
            print('队列已经空了')

if __name__ == "__main__":
    q = Queue(10)
    t1 = threading.Thread(target=producer,q)
    t2 = threading.Thread(target=consumer,q)
    t1.start()
    t2.start()
    t1.join()
    t2.join()